Production Order & Labor Hour APIs

Disclaimer: This is unofficial, community-created documentation for Epicor Prophet 21 APIs. It is not affiliated with, endorsed by, or supported by Epicor Software Corporation. All product names, trademarks, and registered trademarks are property of their respective owners. Use at your own risk.

Overview

P21 provides production order management and labor hour tracking through the Transaction API and Interactive API. There are no dedicated REST endpoints for production or labor -- these capabilities use the existing Transaction and Interactive patterns documented in Transaction API and Interactive API.

Key Characteristics

• No dedicated REST endpoints - Uses Transaction API (/api/v2/transaction) and Interactive API (/api/ui/interactive/v2/)
• Full production lifecycle - Create orders, record labor, track costs, process completions
• OData tables not exposed by default - Production-related tables require SOA Admin configuration before OData access
• Service-based - Each production function maps to a named service

When to Use

• Creating and managing production orders
• Recording labor hours against production orders or service orders
• Maintaining labor codes, work centers, and routing templates
• Tracking production costs (material, labor, freight, process)
• Automating production order processing and completion

Available Services

All services below are accessed through the Transaction API. Use GET /api/v2/services to confirm availability on your P21 instance. Use GET /api/v2/definition/{ServiceName} to retrieve the full schema and template for any service.

Core Production Services

Note: The service name CompletedProducitonOrderAdjustment contains a typo ("Produciton" instead of "Production"). This is P21's actual service name -- you must use the misspelled version in API calls.

Labor & Time Services

Supporting Services

Recording Labor Hours (TimeEntry Service)

The TimeEntry service is the primary service for posting labor hours to production orders. It uses a header/detail pattern with a technician header and one or more labor line items.

Service Definition

Retrieve the full schema with:

GET /api/v2/definition/TimeEntry

Header -- TP_TECHNICIAN.tp_technician (Form)

Labor Lines -- TP_LABORRECORDING.prod_order_line_comp_labor (List)

Example: Record Labor Hours

import httpx

# After authentication and getting ui_server_url...
headers = {"Authorization": "Bearer <token>", "Content-Type": "application/json", "Accept": "application/json"}

payload = {
    "Name": "TimeEntry",
    "UseCodeValues": False,
    "Transactions": [{
        "Status": "New",
        "DataElements": [
            {
                "Name": "TP_TECHNICIAN.tp_technician",
                "Type": "Form",
                "Keys": [],
                "Rows": [{
                    "Edits": [
                        {"Name": "company_id", "Value": "ACME"},
                        {"Name": "technician_id", "Value": "TECH001"},
                        {"Name": "entry_date", "Value": "2026-03-06"}
                    ],
                    "RelativeDateEdits": []
                }]
            },
            {
                "Name": "TP_LABORRECORDING.prod_order_line_comp_labor",
                "Type": "List",
                "Keys": ["prod_order_number"],
                "Rows": [{
                    "Edits": [
                        {"Name": "prod_order_number", "Value": "1001"},
                        {"Name": "service_labor_id", "Value": "LABOR01"},
                        {"Name": "start_time", "Value": "2026-03-06T08:00:00"},
                        {"Name": "end_time", "Value": "2026-03-06T12:00:00"},
                        {"Name": "time_worked", "Value": "4:00"},
                        {"Name": "labor_type_cd", "Value": "Rate"}
                    ],
                    "RelativeDateEdits": []
                }]
            }
        ]
    }]
}

response = httpx.post(
    f"{ui_server_url}/api/v2/transaction",
    headers=headers,
    json=payload,
    verify=False
)
response.raise_for_status()
result = response.json()
print(f"Succeeded: {result['Summary']['Succeeded']}")

var payload = new JObject
{
    ["Name"] = "TimeEntry",
    ["UseCodeValues"] = false,
    ["Transactions"] = new JArray
    {
        new JObject
        {
            ["Status"] = "New",
            ["DataElements"] = new JArray
            {
                new JObject
                {
                    ["Name"] = "TP_TECHNICIAN.tp_technician",
                    ["Type"] = "Form",
                    ["Keys"] = new JArray(),
                    ["Rows"] = new JArray
                    {
                        new JObject
                        {
                            ["Edits"] = new JArray
                            {
                                new JObject { ["Name"] = "company_id", ["Value"] = "ACME" },
                                new JObject { ["Name"] = "technician_id", ["Value"] = "TECH001" },
                                new JObject { ["Name"] = "entry_date", ["Value"] = "2026-03-06" }
                            },
                            ["RelativeDateEdits"] = new JArray()
                        }
                    }
                },
                new JObject
                {
                    ["Name"] = "TP_LABORRECORDING.prod_order_line_comp_labor",
                    ["Type"] = "List",
                    ["Keys"] = new JArray { "prod_order_number" },
                    ["Rows"] = new JArray
                    {
                        new JObject
                        {
                            ["Edits"] = new JArray
                            {
                                new JObject { ["Name"] = "prod_order_number", ["Value"] = 1001 },
                                new JObject { ["Name"] = "service_labor_id", ["Value"] = "LABOR01" },
                                new JObject { ["Name"] = "start_time", ["Value"] = "2026-03-06T08:00:00" },
                                new JObject { ["Name"] = "end_time", ["Value"] = "2026-03-06T12:00:00" },
                                new JObject { ["Name"] = "time_worked", ["Value"] = "4:00" },
                                new JObject { ["Name"] = "labor_type_cd", ["Value"] = "Rate" }
                            },
                            ["RelativeDateEdits"] = new JArray()
                        }
                    }
                }
            }
        }
    }
};

var content = new StringContent(
    payload.ToString(), Encoding.UTF8, "application/json");
var response = await client.PostAsync(
    $"{uiServerUrl}/api/v2/transaction", content);
response.EnsureSuccessStatusCode();

var result = JObject.Parse(
    await response.Content.ReadAsStringAsync());
Console.WriteLine($"Succeeded: {result["Summary"]["Succeeded"]}");

Response

A successful time entry returns:

{
    "Messages": ["Transaction 1:: "],
    "Results": {
        "Name": "TimeEntry",
        "Transactions": [
            {
                "DataElements": [...],
                "Status": "Passed"
            }
        ]
    },
    "Summary": {
        "Succeeded": 1,
        "Failed": 0,
        "Other": 0
    }
}

ProductionOrder Service -- Full Structure

The ProductionOrder service is the most complex production service, with DataElements covering headers, assemblies, components, labor, routing, costs, and completion tracking.

Retrieve the full schema with:

GET /api/v2/definition/ProductionOrder

DataElements

1. TABPAGE_1.tp_1_dw_1 (Form) -- Production Order Header

Key: prod_order_number

Contains 54+ fields for the production order header:

2. TABPAGE_17.tp_17_dw_17 (List) -- Assembly Lines

Assembly items to be manufactured on this production order:

3. TABPAGE_18.components (List) -- Component Materials

Bill of materials for the production order:

4. TP_LABOR.tp_labor (List) -- Labor Entries

Labor lines recorded against the production order:

5. TP_LABORDETAIL.tp_labordetail (Form) -- Labor Entry Detail

Detail view for a selected labor entry:

6. TP_LABORSCHEDULEDISPLAY.tp_laborscheduledisplay (List) -- Labor Schedule/History

Read-only display of labor recorded against the production order:

7. COMPLETION.completion (List) -- Completion Records

Tracks completion milestones with cost breakdowns:

8. ROUTING_TABPAGE.process_x_transaction (Form) -- Routing/Process Info

Routing and process details for the production order:

9. TP_ASSEMBLYCOSTS.tp_assemblycosts (Form) -- Assembly Cost Summary

Estimated vs. actual cost comparison:

Additional DataElements

The ProductionOrder service also includes DataElements for:

• Pick tickets -- Production order picking
• Document links -- Attached documents and files
• Notes -- Order notes and annotations
• Serial numbers -- Serial tracking for produced items
• Lot numbers -- Lot tracking
• Bin locations -- Bin allocation
• Stock availability -- Component availability checking
• PO linkage -- Links to purchase orders for components

Use GET /api/v2/definition/ProductionOrder to see the complete list of DataElements and all available fields.

Labor Service -- Labor Code Maintenance

The Labor service manages labor code definitions including rates, types, and cost structures.

Retrieve the full schema with:

GET /api/v2/definition/Labor

Key Field

service_labor_id -- Unique identifier for the labor code.

Header Fields

Rate Tables

Each labor code can have multiple rate levels:

Cost Data

Cost fields exist at both global and per-location levels:

LaborProcess Service -- Process Templates

The LaborProcess service defines labor process templates with ordered operation sequences. These templates can be applied to production orders to pre-populate labor steps.

Retrieve the full schema with:

GET /api/v2/definition/LaborProcess

Key Field

service_labor_process_id -- Unique identifier for the labor process template.

Header Fields

Labor Process List (Operations)

Interactive API Windows

All of the following windows can be opened via the Interactive API for stateful, step-by-step interaction with full business logic validation. See Interactive API for session management and window operation details.

Note: WorkCenter returns HTTP 500 when opened via the Interactive API. This may require specific licensing or server-side configuration. Use the Transaction API for work center operations instead.

Opening a Production Window

import httpx

# After authentication and getting ui_server_url...
headers = {"Authorization": "Bearer <token>", "Content-Type": "application/json", "Accept": "application/json"}

# Open Production Order Entry window
open_payload = {
    "ServiceName": "ProductionOrder",
    "ResponseWindowHandlingEnabled": False
}

response = httpx.post(
    f"{ui_server_url}/api/ui/interactive/v2/window",
    headers=headers,
    json=open_payload,
    verify=False
)
response.raise_for_status()
result = response.json()
window_id = result["WindowId"]
print(f"Window opened: {window_id}")

# Retrieve a production order
change_payload = {
    "WindowId": window_id,
    "Changes": [{
        "TabName": "TABPAGE_1",
        "DatawindowName": "tp_1_dw_1",
        "FieldName": "prod_order_number",
        "Value": "1001"
    }]
}

response = httpx.put(
    f"{ui_server_url}/api/ui/interactive/v2/change",
    headers=headers,
    json=change_payload,
    verify=False
)
response.raise_for_status()

# Read current window data
response = httpx.get(
    f"{ui_server_url}/api/ui/interactive/v2/data",
    params={"id": window_id},
    headers=headers,
    verify=False
)
response.raise_for_status()
data = response.json()

// Open Production Order Entry window
var openPayload = new JObject
{
    ["ServiceName"] = "ProductionOrder",
    ["ResponseWindowHandlingEnabled"] = false
};

var openContent = new StringContent(
    openPayload.ToString(), Encoding.UTF8, "application/json");
var openResp = await client.PostAsync(
    $"{uiServerUrl}/api/ui/interactive/v2/window", openContent);
openResp.EnsureSuccessStatusCode();

var openResult = JObject.Parse(
    await openResp.Content.ReadAsStringAsync());
var windowId = openResult["WindowId"].ToString();
Console.WriteLine($"Window opened: {windowId}");

// Retrieve a production order
var changePayload = new JObject
{
    ["WindowId"] = windowId,
    ["Changes"] = new JArray
    {
        new JObject
        {
            ["TabName"] = "TABPAGE_1",
            ["DatawindowName"] = "tp_1_dw_1",
            ["FieldName"] = "prod_order_number",
            ["Value"] = "1001"
        }
    }
};

var changeContent = new StringContent(
    changePayload.ToString(), Encoding.UTF8, "application/json");
var changeResp = await client.PutAsync(
    $"{uiServerUrl}/api/ui/interactive/v2/change", changeContent);
changeResp.EnsureSuccessStatusCode();

// Read current window data
var dataResp = await client.GetAsync(
    $"{uiServerUrl}/api/ui/interactive/v2/data?id={windowId}");
dataResp.EnsureSuccessStatusCode();
var data = JObject.Parse(
    await dataResp.Content.ReadAsStringAsync());

Important: Always include DatawindowName in v2 change requests. P21 25.2+ requires it -- omitting it causes Status: 2 (Failure) responses. See Interactive API - DatawindowName Required for details.

Data Access (OData)

Production and labor tables are not exposed in OData by default. To enable OData access to production data:

1. Open SOA Admin > Administration
2. Add production-related tables/views to OData permissions
3. Click Refresh OData API service

Common Tables to Expose

Once exposed, query them via the OData API:

import httpx

# After authentication...
headers = {"Authorization": "Bearer <token>", "Content-Type": "application/json", "Accept": "application/json"}

# Query production orders (after enabling in SOA Admin)
response = httpx.get(
    f"{base_url}/api/dataaccess/v1/prod_order_hdr",
    params={"$filter": "company_id eq 'ACME'", "$top": "10"},
    headers=headers,
    verify=False
)
response.raise_for_status()
orders = response.json()["value"]
for order in orders:
    print(f"PO# {order['prod_order_number']}: {order['complete']}")

var response = await client.GetAsync(
    $"{baseUrl}/api/dataaccess/v1/prod_order_hdr" +
    "?$filter=company_id eq 'ACME'&$top=10");
response.EnsureSuccessStatusCode();

var data = JObject.Parse(
    await response.Content.ReadAsStringAsync());
var orders = data["value"] as JArray;
foreach (var order in orders)
{
    Console.WriteLine(
        $"PO# {order["prod_order_number"]}: {order["complete"]}");
}

See OData API for full query syntax including $filter, $select, $orderby, and $expand.

Best Practices

1. Get definitions first - Always retrieve the service definition (GET /api/v2/definition/{ServiceName}) before building payloads. Field names and valid values vary by P21 version.
2. Use display values - Set UseCodeValues: false for readability (e.g., "Rate" instead of internal codes).
3. Validate labor codes - Ensure service_labor_id values exist before referencing them in TimeEntry payloads. Use the Labor service or OData to look up valid codes.
4. Include DatawindowName - Always include DatawindowName in Interactive API v2 change requests. This is required in P21 25.2+.
5. Check Summary on responses - Always check Summary.Succeeded and Summary.Failed in Transaction API responses.
6. Consider async for bulk - Use the async Transaction endpoint (/api/v2/transaction/async) for large batches of labor entries to avoid session pool issues.
7. Time format - The time_worked field uses HH:MM string format (e.g., "4:00" for 4 hours), not decimal hours.

Common Errors

Code Examples

See the scripts/production/ (Python) and examples/csharp/Production/ (C#) directories for working examples.

Related

• Authentication -- Token generation
• API Selection Guide -- Which API to use when
• Transaction API -- Stateless bulk operations (used by all production services)
• Interactive API -- Stateful window interaction (for complex production workflows)
• Batch Processing Patterns -- Patterns for bulk labor entry