---
title: "Connect Epicor Kinetic to ChatGPT: Manage ERP Orders, Jobs, and Parts"
slug: connect-epicor-kinetic-to-chatgpt-manage-erp-orders-jobs-and-parts
date: 2026-11-01
author: Roopendra Talekar
categories: ["AI & Agents"]
excerpt: "A complete engineering guide to connecting Epicor Kinetic to ChatGPT via an MCP server. Automate orders, query BAQs, and execute ERP workflows using natural language."
tldr: Learn how to securely connect Epicor Kinetic to ChatGPT using Truto's auto-generated MCP servers. Expose Business Activity Queries (BAQs) and ERP tools safely.
canonical: https://truto.one/blog/connect-epicor-kinetic-to-chatgpt-manage-erp-orders-jobs-and-parts/
---

# Connect Epicor Kinetic to ChatGPT: Manage ERP Orders, Jobs, and Parts


If you need to connect Epicor Kinetic to ChatGPT to automate supply chain workflows, manage manufacturing jobs, or orchestrate complex ERP sales orders, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). This server acts as the translation layer between ChatGPT's function calls and Epicor Kinetic's complex OData REST APIs. You can either build and maintain this proxy infrastructure yourself, or use a [managed integration platform like Truto](https://truto.one/best-mcp-server-platform-for-ai-agents-connecting-to-enterprise-saas/) to [dynamically generate a secure, authenticated MCP server URL](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/).

If your team uses Claude, check out our guide on [connecting Epicor Kinetic to Claude](https://truto.one/connect-epicor-kinetic-to-claude-streamline-ap-ar-and-vendor-workflows/) or explore our broader architectural overview on [connecting Epicor Kinetic to AI Agents](https://truto.one/connect-epicor-kinetic-to-ai-agents-automate-supply-chain-and-baqs/).

Giving a Large Language Model (LLM) read and write access to a highly customized, on-premise or cloud-hosted ERP like Epicor Kinetic is a massive engineering challenge. You have to handle rigid relational data payloads, map dynamic Business Activity Queries (BAQs) to MCP tool definitions, and deal with deeply nested Business Object (BO) architectures. Every time an Epicor administrator updates a BAQ or adds a required custom field (UD field) to an order schema, your custom server code must be updated, redeployed, and tested.

This guide breaks down exactly how to use Truto to generate a secure, [managed MCP server for Epicor Kinetic](https://truto.one/best-mcp-server-platform-for-ai-agents-connecting-to-enterprise-saas/), connect it natively to ChatGPT, and execute complex ERP workflows using natural language.

> Stop writing boilerplate ERP integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Epicor Kinetic API

A custom MCP server is a self-hosted integration layer. While the [open MCP standard](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/) provides a predictable way for models to discover tools via JSON-RPC, implementing it against Epicor Kinetic's highly specialized API surface is exceptionally painful.

If you decide to build a custom MCP server for Epicor, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Epicor Kinetic:

### The Complexity of Business Objects (Erp.BO)
Epicor Kinetic does not expose flat, simple REST resources. Instead, it exposes Business Objects (e.g., `Erp.BO.SalesOrderSvc` or `Erp.BO.JobEntrySvc`). Interacting with these services requires understanding the underlying dataset structures. Creating a sales order isn't just a matter of POSTing a generic JSON object; Epicor expects a structured `OrderHed` dataset, and any lines attached require referencing the parent key precisely. If your LLM hallucinates the relational mapping between `OrderNum` and `OrderLine`, the API will outright reject the payload with cryptic server-side exceptions. 

### Business Activity Queries (BAQs) and Dynamic Schemas
In the real world, no two Epicor deployments are the same. Companies rely heavily on custom Business Activity Queries (BAQs) to extract specific, joined data sets (e.g., "Get all open jobs for parts containing specific materials"). Standard static MCP tools cannot account for these custom endpoints. Your MCP server must dynamically read the available BAQs (`BaqSvc`) for the authenticated user and expose them as runnable tools with plain query parameters. Hardcoding standard endpoints guarantees your AI agent will be blind to the company's actual operational data.

### OData Syntax and Pagination Constraints
Epicor relies heavily on OData V3 and V4 standards for querying. When an AI agent needs to find a specific vendor, it must generate a syntactically perfect OData `$filter` string (e.g., `VendorNum eq 5000`). Furthermore, Epicor restricts the number of returned records, requiring strict adherence to pagination cursors or `$top` / `$skip` logic. If you build your own MCP server, you must teach the LLM to paginate accurately or write middleware to abstract the OData complexity away from the model.

## Connect Epicor Kinetic to ChatGPT Quickstart Guide

If you just want the fastest path from a fresh Truto account to ChatGPT calling the Epicor Kinetic API, follow these steps. Deeper architecture, security, and lifecycle details live in the sections below.

**What you need:**
- A Truto account with API access.
- Epicor Kinetic API credentials (ensure REST access is enabled on the Epicor instance).
- A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode available.

### Step 1: Connect Epicor Kinetic as an Integrated Account

In the Truto dashboard, open **Integrated Accounts -> New Integrated Account**, pick Epicor Kinetic, and input the required credentials (Base URL, Username, Password, and Company ID). Truto handles the login token lifecycle (`POST TokenResource.svc`), generating and refreshing the bearer token every 20 minutes automatically so ChatGPT never encounters an expired credential.

### Step 2: Generate an Epicor Kinetic MCP Server

Truto scopes every MCP server to a single integrated account using a cryptographic token. You can generate this URL via the Truto UI or the API.

**Method A: Via the Truto UI**
1. Navigate to the integrated account page for your Epicor connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (e.g., allowing only specific methods like `read`, or tagging specific resources like `sales_orders`).
5. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/<token>`).

**Method B: Via the API**
If you are programmatically provisioning AI access for your users, you can generate the MCP server via a single API call:

```bash
curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Epicor for ChatGPT",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'
```

The response returns a `url` field containing your secure MCP endpoint.

### Step 3: Connect the MCP Server to ChatGPT

With your secure URL in hand, you must register it with your ChatGPT environment. You can do this visually or via a local configuration file.

**Method A: Via the ChatGPT UI**
1. In ChatGPT, navigate to **Settings -> Apps -> Advanced settings**.
2. Toggle **Developer mode** on.
3. Under **MCP servers / Custom connectors**, click to add a new server.
4. **Name:** Epicor Kinetic.
5. **Server URL:** Paste the Truto MCP URL.
6. Click **Save**.

**Method B: Via Manual Config File**
For developers managing local AI environments, you can configure the connection manually. ChatGPT supports SSE-based (Server-Sent Events) MCP connections. Add the following to your MCP client configuration JSON:

```json
{
  "mcpServers": {
    "epicor-kinetic": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<your_secure_token>"
      ]
    }
  }
}
```

Once connected, ChatGPT will execute the `tools/list` JSON-RPC handshake, and Truto will dynamically translate the Epicor Kinetic integration documentation into a list of usable AI tools.

## Epicor Kinetic MCP Hero Tools

Truto automatically generates an expansive inventory of MCP tools for Epicor Kinetic. Rather than exposing raw endpoints, these tools are enriched with descriptions and JSON schemas instructing the LLM exactly how to construct queries, apply OData filters, and format ERP payloads. Here are the highest-leverage tools available for AI agents.

### Execute Business Activity Queries
**Tool:** `list_all_epicor_kinetic_baq_results`

This is arguably the most powerful tool in the Epicor arsenal. It allows ChatGPT to execute custom BAQs configured by the ERP administrator. The LLM passes BAQ parameters as plain query parameters, enabling dynamic execution of complex, pre-joined data views without needing to understand the underlying SQL.

> "Run the 'DailyShipments' BAQ for the date range starting on Monday. Give me a summary of total shipped value by customer."

### Execute Business Object Methods
**Tool:** `epicor_kinetic_business_object_methods_execute`

For complex operations that standard CRUD cannot accomplish, Epicor uses specific business object methods (e.g., `GetNewOrderHed`, `UpdateExt`). This tool executes `POST /api/v2/odata/<Company>/<service>/<method_name>`. The LLM must pass the parameters exactly as named in the instance's REST help.

> "Call the Erp.BO.SalesOrderSvc GetNewOrderHed method to instantiate a new sales order header for customer ID 1045."

### Manage Sales Orders
**Tool:** `list_all_epicor_kinetic_sales_orders`

Queries the `Erp.BO.SalesOrderSvc/SalesOrders` object. The LLM can pass an OData `$filter` to isolate specific orders. Truto handles the cursor-based pagination automatically, fetching up to 100 results per page and seamlessly passing the cursor back to the model.

> "Find all open sales orders for CustNum 1205 where the total amount is greater than $5,000."

### Add Lines to Sales Orders
**Tool:** `create_a_epicor_kinetic_sales_order_line`

Creates a line item for an existing order by interacting with `Erp.BO.SalesOrderSvc/OrderDtls`. The LLM must provide the `order_num` query parameter and the `OrderDtl` column payload. Epicor automatically handles default value injection.

> "Add a line item to Sales Order 50020 for PartNum 'WIDGET-X', quantity 50. Set the required date to next Friday."

### Create Purchase Orders
**Tool:** `create_a_epicor_kinetic_purchase_order`

Generates a new PO via `POST Erp.BO.POSvc/POes`. The LLM sends the `POHeader` columns (like `VendorNum`). Epicor assigns the system key and defaults for terms and shipping.

> "Draft a new purchase order for VendorNum 7780. Leave the lines empty for now, I just need the PO header created."

### Retrieve Manufacturing Jobs
**Tool:** `get_single_epicor_kinetic_job_by_id`

Fetches a specific manufacturing job by its ID from `Erp.BO.JobEntrySvc/JobEntries`. Useful for agentic workflows where customer support needs to check the production status of a backordered item.

> "Check the status of manufacturing job 'JOB-99432'. Is the job closed or still in the engineering phase?"

To view the full inventory of tools, including AP/AR invoicing, vendor management, quote generation, and Epicor Functions execution, visit the [Epicor Kinetic integration page](https://truto.one/integrations/detail/epicorkinetic).

## Workflows in Action

When you give ChatGPT access to Epicor Kinetic via an MCP server, it stops being a passive chat interface and becomes a capable ERP operator. Here are two real-world sequences showing how the model chains tools together to solve business problems.

### Workflow 1: Customer Order Status Investigation
An account manager needs an immediate update on a delayed customer order to prep for a client call.

> "Find the most recent sales order for customer 'Acme Corp'. Check if there are any active manufacturing jobs linked to its parts and tell me the job status."

**How ChatGPT executes this:**
1.  **Lookup Customer:** Calls `list_all_epicor_kinetic_customers` using an OData filter `Name eq 'Acme Corp'` to extract the `CustNum`.
2.  **Lookup Orders:** Calls `list_all_epicor_kinetic_sales_orders` filtering by `CustNum` and ordering by date descending to grab the most recent `OrderNum`.
3.  **Inspect Lines:** Calls `list_all_epicor_kinetic_sales_order_lines` passing `order_num` to extract the `PartNum`s being ordered.
4.  **Check Jobs:** Calls `list_all_epicor_kinetic_jobs` filtering by `PartNum eq '...'` and checking the `JobClosed` and `JobComplete` flags.

**Result:** ChatGPT replies: "Acme Corp's most recent order (Order 54099) includes 20 units of part 'BRACKET-A'. There is currently an active manufacturing job (Job 10293) for this part which is marked as open and in the 'Assembly' phase. It is not yet complete."

### Workflow 2: Automated Custom Reporting via BAQ
A supply chain analyst wants to run a custom internal query without logging into the Epicor desktop client.

> "Run our custom 'LowStockAlert' BAQ for warehouse 'MAIN'. Export the results into a markdown table."

**How ChatGPT executes this:**
1.  **Identify BAQs:** Calls `list_all_epicor_kinetic_baqs` (if it needs to verify the exact ID of the query).
2.  **Execute BAQ:** Calls `list_all_epicor_kinetic_baq_results` passing `baq_id: 'LowStockAlert'` and providing the custom parameter `WarehouseCode: 'MAIN'`.
3.  **Format Output:** The LLM receives the JSON array of rows, parses the fields, and formats them into a markdown table.

**Result:** ChatGPT instantly returns a fully formatted markdown table containing the exact columns designed by the Epicor administrator in the BAQ, saving the user from navigating complex ERP reporting menus.

```mermaid
flowchart TD
    A["ChatGPT Pro<br>(MCP Client)"] -->|"POST /mcp/:token<br>Call BAQ Tool"| B["Truto MCP Server<br>(Stateless Proxy)"]
    B -->|"REST GET<br>/BaqSvc/LowStockAlert/Data"| C["Epicor Kinetic API"]
    C -->|"BAQ JSON Response"| B
    B -->|"JSON-RPC 2.0 Response"| A
```

## Security and Access Control

Giving an LLM access to a mission-critical ERP like Epicor Kinetic requires strict guardrails. Truto's MCP servers are designed with security primitives that keep you in control of what the model can touch.

*   **Method Filtering:** When creating the MCP token, you can restrict the server to specific HTTP verbs. Set `"methods": ["read"]` to ensure ChatGPT can only query Epicor data (like running BAQs or listing jobs) but can never accidentally execute a `POST` or `PATCH` to alter financial records.
*   **Tag Filtering:** Limit the scope of the server to specific operational domains. By applying tags like `["sales", "inventory"]`, the MCP server will only generate tools related to those specific integration resources, hiding sensitive endpoints like payroll or HR entirely.
*   **Additional Authentication (`require_api_token_auth`):** By default, the MCP URL acts as a bearer token. If you check this flag during creation, clients hitting the `/mcp/:token` endpoint must also supply a valid Truto API token in their Authorization header, adding a second layer of identity verification.
*   **Ephemeral Servers (`expires_at`):** For temporary workflows or contractor access, you can pass an ISO datetime to `expires_at`. Truto relies on distributed key-value expiration and durable state alarms to permanently destroy the token at the exact second it expires.

## A Note on Handling Epicor Rate Limits

When automating workflows at scale, AI agents can generate a significant volume of API requests, especially when paginating through large ERP datasets. It is critical to understand how infrastructure handles throttling.

Truto does not retry, throttle, or apply backoff on rate limit errors. When Epicor Kinetic returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller in the JSON-RPC payload. Truto normalizes the upstream rate limit information into standardized HTTP headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller (whether that is ChatGPT or a custom LangGraph agent orchestrator) is strictly responsible for interpreting these headers and implementing its own retry and backoff logic.

## Summary

Connecting ChatGPT to Epicor Kinetic via an MCP server bridges the gap between natural language intelligence and rigid ERP operations. Instead of forcing your team to navigate complex desktop clients or write manual OData queries, you can empower AI agents to query BAQs, check job statuses, and draft purchase orders autonomously.

By leveraging an auto-generated, managed MCP layer, engineering teams can bypass the maintenance burden of tracking schema drift, pagination rules, and token refreshes—allowing them to focus strictly on building high-leverage AI workflows.