Connect Zip to ChatGPT: Manage Procurement and Approval Workflows

If you need to connect Zip to ChatGPT to automate purchase requests, vendor onboarding, or invoice approvals, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Zip's REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on connecting Zip to Claude or explore our broader architectural overview on connecting Zip to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling enterprise procurement ecosystem like Zip is an engineering challenge. You have to map massive JSON schemas to MCP tool definitions, handle complex approval state machines, and enforce strict API boundaries. Every time the underlying API updates an endpoint or deprecates a field, you have to update your server code, redeploy, and test the integration. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Zip, connect it natively to ChatGPT, and execute complex workflows using natural language.

The Engineering Reality of the Zip API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Zip's APIs is painful. You are not just integrating a simple database; you are integrating a strict enterprise state machine governing company spend.

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

Deeply Nested Graph Structures A purchase request in Zip is not a flat record. It contains nested approval chains, dynamic questionnaire responses, price details, and multi-layered vendor hierarchies. Fetching a single request means traversing massive JSON schemas. If you expose this raw schema directly to an LLM, you will instantly blow past your token context windows. You must systematically filter and document the schema so the model understands exactly what price_detail or sla_hours means without hallucinating fields.

Strict State Machine Transitions You cannot simply issue a PATCH request to change an invoice status to "approved" or "paid". Procurement APIs enforce strict state transitions. For example, moving an invoice requires passing it through specific endpoint methods like zip_invoices_submit which run internal completeness validations before transitioning the record into the actual approval workflow. If your MCP server treats Zip like a standard CRUD app, your write operations will consistently fail with cryptic validation errors.

Complex Line Item Coding Modifying a purchase request or invoice requires granular accounting codes. You cannot just pass a price and a description. You must supply the exact identifiers for the GL code, department, subsidiary, and expense category. Your MCP server needs to provide the LLM with the search tools to look up these internal IDs before attempting an update.

Rate Limits and 429 Errors Zip enforces API rate limits to protect its infrastructure. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Zip API returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The LLM framework or the calling client is entirely responsible for reading these headers and implementing its own retry and exponential backoff logic.

The Managed MCP Approach

Instead of forcing your engineering team to build, host, and maintain a custom Node.js or Python server for Zip, you can use a managed platform to generate the MCP server dynamically.

Truto's architecture derives MCP tool definitions directly from the integration's documented API resources. When you connect a Zip account, the platform reads the documentation records - which include descriptions, query schemas, and body schemas - and generates an array of standard JSON-RPC 2.0 tools. A tool only appears in the MCP server if it has a corresponding documentation entry, acting as a strict quality gate. This ensures the LLM is only exposed to curated, well-described endpoints.

Each MCP server is scoped to a single authenticated Zip account. The server URL contains a cryptographically hashed token that routes requests to the correct tenant, meaning the URL alone is enough to authenticate and serve tools to the LLM client.

How to Generate the Zip MCP Server

You can create an MCP server for Zip using either the visual interface or the programmatic REST API. Both methods result in a secure, tokenized URL that you will plug into ChatGPT.

Method 1: Via the Truto UI

If you are setting this up for internal team use, the dashboard is the fastest path.

1. Navigate to the Integrated Accounts page in your Truto environment.
2. Select the connected Zip account you want to expose to ChatGPT.
3. Click the MCP Servers tab.
4. Click the Create MCP Server button.
5. Configure the server. You can restrict the server to specific operations (e.g., only read methods) or specific functional tags.
6. Click Save and copy the generated MCP server URL (it will look like https://api.truto.one/mcp/abc123def456...).

Method 2: Via the REST API

If you are provisioning AI agents programmatically, you can generate MCP servers on the fly using the API. The API validates the configuration, generates a secure token, stores it in a highly available key-value store, and returns the ready-to-use URL.

Make a POST request to the /integrated-account/:id/mcp endpoint:

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Zip Procurement Agent",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'

The response will contain the ID, configuration, and the connection URL:

{
  "id": "mcp_8a7b6c5d",
  "name": "Zip Procurement Agent",
  "config": {
    "methods": ["read", "write", "custom"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8i9j0"
}

Store this url securely. Raw tokens are hashed before storage, meaning even internal system administrators cannot reverse-engineer the URL from the database.

How to Connect the MCP Server to ChatGPT

Once you have the managed URL, you need to register it with your LLM client. You can do this via the ChatGPT desktop application interface or by passing a configuration file to a standard MCP transport layer.

Method A: Via the ChatGPT UI

ChatGPT supports remote MCP servers natively in its desktop and web applications (available on Plus, Team, and Enterprise plans).

1. Open ChatGPT and navigate to Settings.
2. Select Apps and click on Advanced settings.
3. Toggle on Developer mode (this reveals the MCP configuration panel).
4. Under the MCP servers / Custom connectors section, click Add new.
5. Enter a descriptive name (e.g., "Zip Procurement Server").
6. Paste the Truto MCP URL into the Server URL field.
7. Click Save.

ChatGPT will immediately ping the server using the JSON-RPC initialize handshake, discover the Zip tools, and make them available in your chat context.

Method B: Via Manual Config File (SSE Transport)

If you are running a custom agent framework or testing locally with a standard MCP client inspector, you can connect using the Server-Sent Events (SSE) transport wrapper. This is highly useful for headless agent deployments.

Create a configuration JSON file (e.g., zip_mcp_config.json) and configure the client to use the official MCP SSE proxy command:

{
  "mcpServers": {
    "zip_procurement": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8i9j0"
      ]
    }
  }
}

When your agent initializes, it spawns the Node process which establishes a persistent SSE connection to the remote Truto server, seamlessly proxying local tool calls to the remote Zip instance.

Zip Hero Tools for AI Agents

The MCP server exposes a massive surface area of the Zip API. However, your AI agents will primarily rely on a core set of "hero tools" to execute high-value procurement workflows. Here are the most critical tools automatically generated and injected into your ChatGPT context.

1. list_all_zip_requests

This is the foundational tool for reading the procurement pipeline. It searches and lists Zip purchase requests based on various filter and sort parameters, returning comprehensive records including the amount, vendor, requester, and priority status.

Usage note: Because requests are nested, the LLM will see objects like price_detail and payment_method. If you are building reporting agents, instruct the LLM to paginate by passing back the next_cursor unchanged.

"Find all purchase requests created this week that are in the 'pending_approval' status and have a total USD amount greater than 10,000."

2. list_all_zip_approvals

While requests track the spend, approvals track the humans. This tool searches approvals in Zip and returns node records including the status, node type, start time, due date, SLA hours, and the specific assignee.

Usage note: Use this tool when the agent needs to identify blockages in the procurement pipeline or ping specific managers who have breached their SLA.

"Look up all pending approvals assigned to John Doe. Check the SLA hours and tell me if any of them are currently overdue."

3. update_a_zip_request_line_item_by_id

This tool allows the agent to modify the specific line items on an existing Zip request. It accepts updates for the description, quantity, rate, line type, department, and GL code.

Usage note: The agent must have the specific request_id and the line item id before calling this. The LLM must be instructed to look up the correct GL code using the list_all_zip_gl_codes tool if it doesn't already know it.

"Update line item 98765 on purchase request PR-1024. Change the quantity to 50 and update the department code to 'Engineering'."

4. create_a_zip_vendor

This tool creates or updates a vendor in Zip, keyed by external_id. It accepts detailed payloads including legal names, addresses, contacts, and categorical data.

Usage note: This is technically an upsert operation. If the external_id matches an existing vendor, it updates the record. Ensure your prompt provides all mandatory structural data (like country codes and contact emails) to prevent API validation failures.

"Create a new vendor profile for 'Acme Corp'. Their external ID is 'V-889'. Add an address in San Francisco and set their category to 'Software Subscriptions'."

5. zip_invoices_submit

This is a custom lifecycle method that transitions a draft invoice into the formal approval workflow. It runs Zip's internal validation engine on the backend.

Usage note: Do not try to update the invoice status directly. Always use this tool to finalize an invoice. If the invoice is missing required coding or PO matching, this tool will return a validation error which the LLM must read and resolve.

"Submit invoice INV-2024-001 for approval. If it returns an error about missing GL codes, tell me what is missing so we can fix it."

6. list_all_zip_purchase_orders

This tool retrieves formal purchase orders generated from approved requests. It returns records including the PO number, total amount, vendor, billing amounts, and status.

Usage note: Highly useful for reconciliation workflows where the agent needs to cross-reference an incoming invoice against an open PO.

"Find the open purchase order associated with vendor Acme Corp. Verify if the total open amount is sufficient to cover a $5,000 invoice."

Workflows in Action

By chaining these tools together, ChatGPT transitions from a simple chat interface into a fully autonomous procurement assistant. Here are real-world examples of how an agent uses the MCP server to solve complex tasks.

Scenario 1: Unblocking a Stalled Purchase Request

IT administrators frequently waste hours tracking down why software renewals are stuck in procurement. You can instruct ChatGPT to audit the pipeline and identify the bottleneck.

"Check the status of the Datadog renewal purchase request. Find out exactly whose approval is blocking it, how long it has been sitting there, and draft an update summarizing the delay."

Execution Steps:

1. The agent calls list_all_zip_requests searching by name ("Datadog") to retrieve the core request ID and confirm its status.
2. The agent calls list_all_zip_approvals filtering by that specific request ID to inspect the approval nodes.
3. It identifies the node with status: pending and extracts the assignee and sla_hours.
4. The agent formulates a response detailing exactly who needs to approve the request and how far past the SLA they are.

Scenario 2: Invoice Verification and Submission

Processing inbound invoices requires cross-referencing vendor data and ensuring the invoice is tied to an active PO before submitting it to the workflow.

"We received a new invoice from Cloudflare for $2,000. Verify that we have an open PO for them with enough remaining budget, and if so, submit the draft invoice for approval."

Execution Steps:

1. The agent calls list_all_zip_vendors searching for "Cloudflare" to get the internal vendor_id.
2. The agent calls list_all_zip_purchase_orders filtering by that vendor_id to retrieve active POs and checks the total_amount against existing spend.
3. Assuming a draft invoice was created via OCR or another system, the agent calls zip_invoices_submit passing the target invoice ID to transition it into the approval chain.

sequenceDiagram
    participant User as ChatGPT (User Prompt)
    participant Router as MCP Protocol Router
    participant Zip as Upstream API (Zip)
    
    User->>Router: Call tools/call (list_all_zip_vendors)
    Router->>Zip: GET /vendors?query=Cloudflare
    Zip-->>Router: Returns Vendor ID 8832
    Router-->>User: Tool Result (Vendor Data)
    
    User->>Router: Call tools/call (list_all_zip_purchase_orders)
    Router->>Zip: GET /purchase_orders?vendor_id=8832
    Zip-->>Router: Returns Open PO Data
    Router-->>User: Tool Result (PO Data)
    
    User->>Router: Call tools/call (zip_invoices_submit)
    Router->>Zip: POST /invoices/{id}/submit
    Zip-->>Router: 200 OK (Workflow Triggered)
    Router-->>User: Tool Result (Success)

Security and Access Control

Giving an AI agent access to financial workflows introduces severe security considerations. The managed MCP architecture provides multiple layers of control to constrain what the agent can do.

• Method Filtering: When creating the MCP server, you can restrict the config.methods array to ["read"]. This drops all create, update, and delete tools from the LLM's context, ensuring the agent can audit purchase requests but cannot accidentally approve them.
• Tag Filtering: Zip resources are categorized by functional tags. You can pass config.tags: ["invoices"] to restrict the server so it only exposes invoice-related endpoints, hiding vendor onboarding and employee data.
• Additional Authentication: By setting require_api_token_auth: true, the tokenized URL is no longer sufficient on its own. The connecting client must also pass a valid Truto environment API token in the Authorization header. This prevents unauthorized execution if the URL is leaked in logs or shared spaces.
• Time-To-Live (TTL): You can set an expires_at timestamp when generating the server. Once the deadline passes, distributed cleanup alarms automatically purge the configuration and invalidate the URL, making it perfect for temporary contractor access or scoped audit agents.

Moving Forward with AI-Driven Procurement

Connecting Zip to ChatGPT fundamentally shifts how organizations handle procurement operations. By utilizing a managed MCP server, you bypass the friction of writing pagination loops, building schema definitions, and managing OAuth lifecycles. Your engineering team can focus entirely on prompting and workflow orchestration, while the infrastructure handles the translation layer. With strict read/write boundaries and programmatic server generation, you can confidently scale AI agents across your financial operations without compromising control.