Connect Procurify to ChatGPT: Manage Requisitions and Bills

If you want to connect Procurify to ChatGPT so your AI agents can automate purchase requisitions, update purchase orders, triage accounts payable, and manage vendors, you need a Model Context Protocol (MCP) server. If your team uses Claude, check out our guide on connecting Procurify to Claude or explore our broader architectural overview on connecting Procurify to AI Agents.

Giving a Large Language Model (LLM) read and write access to an enterprise spend management platform is a serious engineering challenge. You either spend weeks building, hosting, and maintaining a custom MCP server to translate LLM JSON arguments into Procurify's highly specific payload structures, or you use a managed infrastructure layer.

This guide breaks down exactly how to use Truto to generate a secure, authenticated MCP server for Procurify, connect it natively to ChatGPT, and execute complex procurement workflows using natural language.

The Engineering Reality of the Procurify 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 Procurify's highly specific API is exceptionally painful.

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

Rigid State Machines for Purchase Orders

You cannot simply run a PUT request to update a closed Purchase Order in Procurify. The platform enforces a strict financial state machine. To modify a closed PO, you must first call a specific reopening endpoint, apply your edits, and handle the document versioning. If your custom MCP server does not map these state dependencies correctly, ChatGPT will confidently attempt invalid writes and fail with opaque 400 Bad Request errors.

Nested Line Items and Receipt Quantities

Requisitions and bills are not flat data objects. A single requisition can contain dozens of line items, each mapped to different account codes, departments, and custom fields. Furthermore, when receiving items, you do not just mark an order as "received" - you must pass exact pass/fail quantity metrics against specific order item IDs. Generating accurate JSON schemas for the LLM to understand this nesting requires deep, manual API mapping.

Custom Field Canonicalization

Procurify relies heavily on custom fields for order items and bills. The API expects canonical custom field IDs, not human-readable labels. Your MCP server needs to dynamically fetch and cache these field definitions so the LLM knows which internal IDs map to the dropdown choices a user expects to see. If you skip this, your AI agent will hallucinate field names.

Transparent Rate Limit Handling

Procurement workflows often involve bulk operations - like syncing a massive vendor list or updating dozens of historical POs - which frequently trigger API rate limits. It is critical to understand that Truto's proxy architecture does not automatically retry, throttle, or apply backoff to these requests.

When the Procurify API returns an HTTP 429 Too Many Requests error, Truto immediately passes that error back to the caller. Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). Your client application or agent framework is entirely responsible for reading these headers and implementing its own retry or backoff logic.

How to Connect Procurify to ChatGPT

Instead of building this infrastructure from scratch, you can use Truto to dynamically generate a Procurify MCP server. The server derives its tool definitions directly from the integration's documented API schemas, ensuring ChatGPT always has an accurate understanding of the available endpoints.

flowchart LR
  A["ChatGPT Client<br>(Desktop/Web)"] -->|"JSON-RPC<br>over HTTP POST"| B["Truto MCP Server<br>(/mcp/:token)"]
  B -->|"Token Auth &<br>Method Filtering"| C["Edge Storage &<br>Routing Layer"]
  C -->|"Normalized Request"| D["Truto Proxy API"]
  D -->|"Native REST"| E["Procurify API"]

Here is the step-by-step process for generating the server and connecting it to ChatGPT. We will cover both the UI-driven approach and the API-driven approach.

Step 1: Connect the Procurify Account

Before generating an MCP server, you need an active authenticated connection to a Procurify instance.

1. In the Truto dashboard, navigate to Integrated Accounts -> New Integrated Account.
2. Select Procurify from the catalog.
3. Complete the OAuth flow.

Truto securely manages the OAuth lifecycle, storing the refresh token and automatically refreshing access tokens before they expire. Your MCP server will never fail due to a stale credential.

Step 2: Generate the Procurify MCP Server

An MCP server in Truto is scoped to a single integrated account. You can create this server via the Truto UI or programmatically via the API.

Option A: Via the Truto UI (Recommended for Admins)

1. Navigate to the Integrated Accounts page and select your active Procurify connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure your server settings (name, allowed methods, allowed tags, and expiration).
5. Click Create and securely copy the generated MCP server URL. It will look like https://api.truto.one/mcp/<token>.

Option B: Via the Truto API (Recommended for Developers) You can programmatically provision an MCP endpoint by making a POST request to Truto. This is ideal for SaaS platforms dynamically provisioning AI access for their end-users.

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": "Procurify Procurement Assistant",
    "config": {
      "methods": ["read", "write"],
      "tags": ["purchase_orders", "bills", "vendors"]
    }
  }'

The API validates the configuration and returns a database record containing the secure url. This single URL handles routing, authentication, and tool discovery - treat it like a secret.

Step 3: Register the Server in ChatGPT

Now that you have your secure MCP URL, you need to register it with your LLM client.

Option A: Via the ChatGPT UI Note: Custom connectors via remote MCP are currently available for ChatGPT Pro, Plus, Business, Enterprise, and Education accounts.

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode.
3. Under MCP servers / Custom connectors, click Add to register a new server.
4. Provide a recognizable name (e.g., "Procurify Truto").
5. Paste your Truto MCP Server URL into the configuration.
6. Click Save. ChatGPT will immediately handshake with the server and list the available Procurify tools.

Option B: Via Manual Configuration File (For CLI/Desktop tools) If you are using a local developer environment, an open-source agent framework, or a client that requires a standard MCP JSON configuration, you can use the official Server-Sent Events (SSE) bridge. Add the following to your MCP configuration file:

{
  "mcpServers": {
    "procurify-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/<YOUR_TOKEN>"
      ]
    }
  }
}

High-Leverage Procurify MCP Tools

When ChatGPT connects to the MCP server, it dynamically discovers tools based on Procurify's API documentation. Truto handles the schema parsing, mapping the integration's resources into callable operations.

Here are the hero tools your AI agents will use to automate spend management workflows.

1. Create a Requisition

Tool name: create_a_procurify_requisition

This is the starting point for spend management. This tool allows the AI to submit a purchase request along with all necessary line items. It handles nested data seamlessly, requiring the location, department, and item details in a single payload.

"I need to order three MacBook Pros for the engineering team in the New York office. Draft a requisition for these items assigned to the IT Hardware department and set the required date to next Friday."

2. Update a Purchase Order

Tool name: update_a_procurify_purchase_order_by_id

This tool executes a full update (PUT) on an existing purchase order using its Procurify PO number. It is highly complex, requiring the full state of the PO - including buyer details, receiver details, order items, taxes, and discounts. It is essential for revising orders before they are finalized.

"Pull PO number 4059. Update the receiver contact to Sarah Jenkins, change the promise date to the 15th, and apply a 5% discount to the total order. Save the updated version."

3. Receive Order Items

Tool name: create_a_procurify_receipt_item

Procurement doesn't end at the purchase order. This tool allows the agent to log receiving actions against specific order items. You must pass exact metrics for what was received successfully (pass_quantity) and what arrived damaged or incorrect (fail_quantity).

"We just got the shipment for PO 4059. Mark 2 of the laptops as passed, but log 1 laptop as failed because the screen was cracked in transit."

4. List Accounts Payable Bills

Tool name: list_all_procurify_bills

This is the core tool for AP triage. It lists bills across the organization, filterable by status, date ranges, vendor IDs, and export states. AI agents use this tool to compile unmapped liabilities or find bills pending approval.

"Find all unapproved accounts payable bills from Dell over the last 30 days and summarize their total amounts."

5. Mark Bills as Paid

Tool name: create_a_procurify_bill_paid_marking

Once bills are approved and funds are disbursed, they need to be closed out. This tool marks approved bills that currently have no payment as paid. It accepts an array of bill UUIDs and a specific payment date.

"Take the three approved AWS invoices from last month and mark them all as paid in Procurify using today's date."

6. Manage Vendors

Tool name: list_all_procurify_vendors

Vendor directories get messy. This tool allows the agent to search and filter vendors by group, type, and active status. It returns comprehensive details including addresses, scoring, and operational states.

"List all active preferred vendors in the IT Services category located in California."

For the complete inventory of available operations, required parameters, and JSON schema definitions, review the Procurify integration page.

Workflows in Action

MCP tools are powerful in isolation, but their true value emerges when an LLM orchestrates them sequentially to execute multi-step workflows. Here are two real-world scenarios.

Workflow 1: Purchase Order Fulfillment and Receiving

Persona: Procurement Manager

"Check the status of purchase order PO-8812. If it is fully purchased, mark all 50 standing desks as received in good condition, and then pull the vendor profile for the supplier to ensure their contact email is up to date."

How the agent executes this:

1. Calls get_single_procurify_purchase_order_by_id using the PO number to verify the status is purchased and to extract the specific order_item IDs.
2. Calls create_a_procurify_receipt_item for the desk item ID, setting pass_quantity to 50 and fail_quantity to 0.
3. Parses the vendor ID from the initial PO response.
4. Calls get_single_procurify_vendor_by_id to retrieve the supplier's profile.

The result: The user receives a natural language confirmation that the inventory was received without discrepancies, alongside the vendor's current contact information - a process that normally takes a dozen clicks in the UI.

Workflow 2: AP Invoice Triage and Payment Marking

Persona: Accounts Payable Specialist

"Find all approved bills from 'Acme Corp' from last week. Give me a summary of the totals, and if they look correct, go ahead and mark them as paid for today."

sequenceDiagram
  participant AP as AP Specialist
  participant GPT as ChatGPT
  participant MCP as Truto MCP Server
  participant Proc as Procurify API

  AP->>GPT: "Find approved bills from Acme Corp..."
  GPT->>MCP: Call list_all_procurify_bills (status=approved, vendor=Acme Corp)
  MCP->>Proc: GET /bills
  Proc-->>MCP: [bill_uuid_A, bill_uuid_B]
  MCP-->>GPT: Return bill records
  GPT-->>AP: "Found 2 bills totaling $4,500. Proceed with payment?"
  AP->>GPT: "Yes, mark them as paid."
  GPT->>MCP: Call create_a_procurify_bill_paid_marking (uuids, today's date)
  MCP->>Proc: POST /bills/mark-paid
  Proc-->>MCP: Success
  MCP-->>GPT: Return payment confirmation
  GPT-->>AP: "Successfully marked 2 bills as paid."

Security and Access Control

Giving AI models access to financial and procurement data requires strict boundary management. Truto MCP servers provide multiple layers of security to constrain what ChatGPT can see and do.

• Method Filtering: Limit the server's capabilities at creation time. You can enforce a read-only environment by setting config.methods: ["read"], which ensures the server only exposes GET and LIST endpoints, physically preventing the LLM from creating or updating financial records.
• Tag Filtering: Group tools by functional area using config.tags. If you only want an agent to handle vendor management, you can restrict the server to tags like ["vendors"], completely isolating it from bills and requisitions.
• API Token Authentication: For elevated security, enable require_api_token_auth: true. This forces the client to pass a valid Truto API token in the Authorization header, ensuring that possession of the MCP URL alone is not enough to execute tools.
• Automatic Expiration: Grant temporary access to contractors or automated workflows by setting an expires_at timestamp. Once the timestamp passes, the edge storage invalidates the token and an automated cleanup routine completely destroys the server record.

Automate Spend Management Today

Connecting Procurify to ChatGPT transforms procurement from a manual data-entry chore into a conversational, agentic workflow. Instead of navigating complex UIs to receive line items or triage bills, your team can command workflows via natural language.

By leveraging Truto's dynamically generated MCP servers, you eliminate the need to write schema parsers, maintain custom integration infrastructure, or handle OAuth token refreshes. You get secure, fully managed API access out of the box.