Connect Zip to Claude: Automate Vendor Onboarding and Invoicing

If you need to connect Zip to Claude to automate vendor onboarding, track purchase requests, or manage invoice approvals, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude'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 ChatGPT, check out our guide on connecting Zip to ChatGPT or explore our broader architectural overview on connecting Zip to AI Agents.

Giving a Large Language Model (LLM) read and write access to a complex spend management platform like Zip presents a massive engineering challenge. Procurement systems rely on strict state machines, deeply nested object relationships (vendors to contacts to addresses to payment methods), and dynamic approval graphs. Every time Zip introduces a new feature or updates a payload schema, your custom MCP server has to adapt.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Zip, connect it natively to Claude, and execute complex procurement 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, implementing it against B2B vendor APIs requires heavy lifting. You are not just building a proxy - you are translating complex operational logic into discrete, schema-validated functions that an LLM can understand and execute reliably.

If you decide to build a custom MCP server for Zip, you own the entire API lifecycle. Here are the specific challenges you will face:

Deeply Nested Payload Structures Zip is a system of record for procurement. Operations like creating a vendor do not accept flat JSON objects. A vendor creation payload requires arrays of addresses with specific sub-types, payment method objects tied to specific currencies, and nested contact objects. If you ask an LLM to generate these payloads from scratch using raw API documentation, it will frequently hallucinate property names or fail schema validation. A well-designed MCP server must abstract these complex data requirements into clear JSON Schemas mapped exactly to the integration's real requirements.

Strict State Transitions You cannot simply "update" the status of an invoice or purchase request arbitrarily. Zip enforces rigid lifecycle rules - a request must pass through specific approval nodes, and invoices must be drafted before they can be submitted via specific endpoints (like /invoices/submit). Your MCP tools must reflect these discrete operational boundaries rather than generic CRUD actions, ensuring Claude only attempts valid state transitions.

Rate Limiting and Retry Responsibility Zip enforces limits on API traffic. When an agent attempts to pull hundreds of historical invoices or crawl through paginated approval queues, it can easily trigger an HTTP 429 Too Many Requests response. It is a critical architectural distinction that Truto does not retry, throttle, or absorb these rate limit errors. Instead, Truto passes the 429 error directly back to the caller, normalizing the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller (your agent framework) is strictly responsible for implementing exponential backoff.

How to Generate a Zip MCP Server with Truto

Truto dynamically generates MCP tools based on documentation records linked to the integration's resources. When you create an MCP server, Truto inspects the Zip integration, pulls the schemas, and constructs the JSON-RPC tool definitions on the fly.

You can generate the MCP server URL in two ways: through the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

For ad-hoc agent testing or internal workflows, the UI is the fastest path.

1. Navigate to the integrated account page for your Zip connection in the Truto dashboard.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure the server (give it a name, restrict it to read or write methods, or filter by tags like vendors or invoices).
5. Click Save and copy the generated MCP server URL.

Method 2: Via the API

For production workflows where you deploy AI agents programmatically, you can dynamically provision MCP servers scoped to specific Zip tenants.

Make an authenticated 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 MCP",
    "config": {
      "methods": ["read", "write", "custom"]
    },
    "expires_at": "2025-12-31T23:59:59Z"
  }'

The API provisions the server and returns the endpoint URL:

{
  "id": "mcp_abc123",
  "name": "Zip Procurement Agent MCP",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": "2025-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/token_xyz987..."
}

This URL contains a secure hash that identifies the integrated account and configuration. It is fully self-contained.

How to Connect the Zip MCP Server to Claude

Once you have the Truto MCP URL, you can connect it to your LLM interface. Here are the two standard methods for Anthropic users.

Method A: Via the Claude UI (Custom Connectors)

If you are using Claude's enterprise or team plans that support Custom Connectors, configuration requires zero code.

1. Open Claude and navigate to Settings -> Integrations -> Add MCP Server.
2. Enter a recognizable name (e.g., "Zip Spend Management").
3. Paste the Truto MCP URL you generated in the previous step.
4. Click Add.

Claude will perform the MCP initialization handshake, discover the dynamically generated Zip tools, and immediately surface them to the model context.

Method B: Via the claude_desktop_config.json File

If you are running Claude Desktop locally as a developer, you connect remote MCP servers using a Server-Sent Events (SSE) transport wrapper.

Open your claude_desktop_config.json file (typically located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS) and add the Truto URL:

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

Restart Claude Desktop. The application will execute the wrapper command and negotiate the tool list with Truto.

Security and Access Control

Providing an LLM direct access to enterprise spend systems requires strict boundaries. Truto provides several architectural layers to secure your MCP servers:

• Method Filtering: Control exactly what operations the model can perform via the config.methods array. You can limit a server to ["read"] to prevent accidental vendor updates, or specify exact actions like ["get", "list"].
• Tag Filtering: Scope the available tools to specific domains. Using config.tags, you can restrict an agent to only see tools tagged with ["approvals"] or ["invoices"], completely hiding sensitive employee or departmental endpoints.
• Mandatory API Token Authentication: By enabling require_api_token_auth: true, possession of the MCP URL is no longer enough to invoke a tool. The client must also send a valid Truto API token in the Authorization header, mapping the execution back to a specific authenticated user in your system.
• Automated Expiration: Temporary agents (e.g., a script running an end-of-month reconciliation) should not have permanent access. Setting expires_at during creation schedules a durable edge cleanup that revokes the token automatically at the specified time.

Core Zip MCP Tools

When connected, Truto exposes Zip's API endpoints as flattened, schema-validated tools. Here are the core tools available for procurement automation.

list_all_zip_vendors

Search and list vendors matching specific criteria. This is the starting point for checking if a supplier already exists before initiating a new onboarding flow.

"Find the vendor ID and status for 'Acme Corp' in our Zip instance. Return their payment terms if available."

create_a_zip_vendor

Creates or updates (upserts) a vendor record. This tool handles the complex nested structures required for contacts, addresses, and external IDs.

"Create a new vendor profile for 'TechSupply Inc' using the external ID 'VND-4912'. Include John Doe (john@techsupply.com) as the primary contact."

list_all_zip_requests

Search purchase requests across the organization. This supports filtering by department, requester, amount, and status.

"List all pending purchase requests for the Engineering department submitted in the last 7 days that exceed $10,000."

list_all_zip_approvals

Extracts pending or completed approval nodes. This is vital for auditing bottlenecks in the procurement cycle and checking SLA violations.

"Check my pending approvals queue in Zip. Which requests have breached their SLA hours?"

zip_invoices_submit

Transitions a draft invoice into the formal approval workflow. This triggers Zip's internal validation engines and routing rules.

"Submit invoice ID 'INV-99234' for approval. Ensure it is mapped to the Marketing budget before submitting."

create_a_zip_budget

Create or update a budget allocation for a specific fiscal period and set of dimensions (e.g., department or cost center).

"Upsert the Q3 budget for the Marketing department, setting the total allocated amount to $150,000 for the period starting July 1st."

For the complete tool inventory and JSON Schema definitions - including endpoints for purchase orders, vendor credits, sub-queues, and e-invoices - visit the Zip integration page.

Workflows in Action

Connecting tools to an LLM unlocks multi-step, autonomous workflows. Here is how an AI agent executes real procurement tasks using the Zip MCP server.

Scenario 1: Autonomous Vendor Onboarding & Invoice Routing

An operations manager receives a PDF invoice from a new supplier via email and asks their AI assistant to handle the onboarding and payment routing.

"Check if 'Global Logistics LLC' is in Zip. If they aren't, create them as a new vendor. Then draft an invoice for $4,500 under their account and submit it for approval."

Execution Steps:

1. Search: Claude calls list_all_zip_vendors with the search query "Global Logistics LLC".
2. Evaluate: The agent sees an empty result array. It determines it must create the vendor.
3. Onboard: Claude calls create_a_zip_vendor, formatting the provided data into Zip's required schema.
4. Draft: Using the new vendor ID, Claude calls create_a_zip_invoice with the $4,500 amount.
5. Submit: Finally, Claude calls zip_invoices_submit using the newly generated invoice ID, pushing it into the organization's approval queue.

The manager gets a confirmation message that the vendor was created and the invoice is pending department sign-off.

sequenceDiagram
    participant User as "Operations Manager"
    participant Claude as "Claude Desktop"
    participant Truto as "Truto MCP Server"
    participant Upstream as "Zip API"

    User->>Claude: "Check vendor, onboard, and submit invoice..."
    Claude->>Truto: list_all_zip_vendors(name: "Global Logistics LLC")
    Truto->>Upstream: GET /vendors?search=...
    Upstream-->>Truto: [] (Empty)
    Truto-->>Claude: Result: Not Found

    Claude->>Truto: create_a_zip_vendor(...)
    Truto->>Upstream: POST /vendors
    Upstream-->>Truto: 200 OK (Vendor ID: V-123)
    Truto-->>Claude: Success

    Claude->>Truto: create_a_zip_invoice(vendor_id: "V-123", amount: 4500)
    Truto->>Upstream: POST /invoices
    Upstream-->>Truto: 200 OK (Invoice ID: INV-789)
    Truto-->>Claude: Success

    Claude->>Truto: zip_invoices_submit(invoice_id: "INV-789")
    Truto->>Upstream: POST /invoices/INV-789/submit
    Upstream-->>Truto: 200 OK
    Truto-->>Claude: Success
    Claude-->>User: "Vendor created. Invoice submitted."

Scenario 2: Finance Controller Budget Audit

A finance controller needs to unblock procurement operations before the end of the quarter, requiring the AI to cross-reference requests against budgets and queue assignments.

"Find all open purchase requests over $50k that are pending my approval. Check our current budget actuals to ensure we have capacity to approve them."

Execution Steps:

1. Retrieve Approvals: Claude calls list_all_zip_approvals filtered by the controller's user ID and a 'pending' state.
2. Lookup Request Details: For the high-value approvals, Claude calls get_single_zip_request_by_id to pull the line item details and department allocations.
3. Cross-Reference Budget: Claude calls list_all_zip_budgets to check the remaining capacity for the relevant department.
4. Report: The agent synthesizes the data, summarizing the pending requests and comparing them to the remaining budget bandwidth.

Strategic Wrap-Up

Connecting Zip to Claude via an MCP server turns a passive procurement system into an active, agent-driven command center. By utilizing a managed integration layer, engineering teams avoid the grueling work of managing OAuth states, mapping nested vendor schemas, and tracking upstream API changes.

Truto handles the protocol translation, allowing your AI agents to safely read from and write to Zip using predictable, schema-validated tools.