---
title: "Connect Amazon Vendor Central to Claude: Automate Orders & Shipments"
slug: connect-amazon-vendor-central-to-claude-automate-orders-shipments
date: 2026-10-31
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "Learn how to build a managed MCP server to connect Amazon Vendor Central to Claude. Automate direct fulfillment orders, shipments, and invoicing via AI."
tldr: "Step-by-step engineering guide to exposing the Amazon Vendor Central SP-API to Claude via Truto's managed MCP server. Covers Restricted Data Tokens (RDTs), IETF rate limit header normalization, and AI-driven direct fulfillment workflows."
canonical: https://truto.one/blog/connect-amazon-vendor-central-to-claude-automate-orders-shipments/
---

# Connect Amazon Vendor Central to Claude: Automate Orders & Shipments


If you need to connect Amazon Vendor Central to Claude to automate direct fulfillment (DF) orders, process shipping labels, or [audit catalog items](https://truto.one/connect-amazon-vendor-central-to-chatgpt-sync-catalog-a-content/), you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between Claude's natural language tool calls and Amazon's REST-based Selling Partner API (SP-API). You can either build and maintain this translation layer yourself, or use a managed integration platform like Truto to dynamically generate a [secure, authenticated MCP server URL](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). If your team uses ChatGPT, check out our guide on [/connect-amazon-vendor-central-to-chatgpt-sync-catalog-a-content/](https://truto.one/connect-amazon-vendor-central-to-chatgpt-sync-catalog-a-content/) or explore our broader architectural overview on [/connect-amazon-vendor-central-to-ai-agents-manage-data-operations/](https://truto.one/connect-amazon-vendor-central-to-ai-agents-manage-data-operations/).

Giving a Large Language Model (LLM) read and write access to a sprawling, high-stakes supply chain ecosystem like Amazon Vendor Central is a serious engineering challenge. You have to handle Login with Amazon (LWA) token lifecycles, navigate Restricted Data Tokens (RDTs) for sensitive customer data, and respect strict, unforgiving API quotas. Every time Amazon migrates an endpoint or changes a payload requirement, your custom server code breaks.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Amazon Vendor Central, connect it natively to Claude Desktop, and execute complex direct fulfillment and catalog workflows using natural language.

> Want to give your AI agents secure, authenticated access to Amazon Vendor Central and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Amazon Vendor Central API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable JSON-RPC 2.0 interface for models to discover and execute tools, the reality of implementing it against Amazon's Selling Partner API (SP-API) is exceptionally painful. You are dealing with an API designed for enterprise-scale ERP synchronization, not conversational AI.

If you decide to [build a custom MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/) for Amazon Vendor Central, here are the specific integration challenges you will face:

**Restricted Data Tokens (RDTs) and PII Protection**
Amazon strictly enforces data privacy. Standard Login with Amazon (LWA) OAuth tokens are not enough to access Personally Identifiable Information (PII) like shipping names, physical addresses, or phone numbers found in Direct Fulfillment (DF) orders. To retrieve a shipping label or view order details, your system must first generate a temporary Restricted Data Token (RDT) via a separate API call, explicitly requesting access to specific restricted resources. If you build this manually, your MCP server must intercept Claude's request, pause execution, negotiate the RDT, inject it into the payload, and then forward the request to Amazon. 

**Fragmented Token Auth (Standard vs. Grantless)**
The vast majority of the SP-API requires a standard LWA access token delegated by the vendor. However, certain administrative actions - like configuring notification destinations or tracking shipment status - require a "grantless" token created using your developer app's raw client credentials. Your MCP proxy layer has to instantly know which authentication scheme to apply based on the specific endpoint the LLM is trying to call.

**Strict, Low-Ceiling Rate Limits**
Amazon protects its infrastructure with aggressive token-bucket rate limits. Direct Fulfillment endpoints frequently cap at a sustained rate of 10 requests per second with a burst limit of 10. Catalog search endpoints drop as low as 2 requests per second. When building an MCP server, you cannot let the LLM blindly hammer the API, but you also cannot swallow rate limit errors silently, or the LLM will hallucinate successful operations.

## How Truto's Managed MCP Architecture Works

Truto solves these problems by dynamically converting your connected Amazon Vendor Central integration into an MCP-compatible JSON-RPC endpoint. 

The architecture is heavily documentation-driven. Instead of engineers writing individual Python or TypeScript wrappers for all 200+ SP-API endpoints, Truto inspects the integration's internal API schemas and automatically generates flat, LLM-friendly tool definitions. If an endpoint requires nested JSON, Truto flattens the query and body parameters into a single schema for Claude, then reconstructs the proper hierarchy before proxying the request to Amazon.

### Factual Note on Rate Limits and Error Handling

When exposing APIs to [AI agents](https://truto.one/connect-amazon-vendor-central-to-ai-agents-manage-data-operations/), handling 429 Too Many Requests errors correctly is critical to prevent cascading failures. 

**Truto enforces a strict pass-through philosophy for rate limit errors: it does not retry, throttle, or apply backoff internally.**

When Amazon Vendor Central hits a rate limit and returns an HTTP 429, Truto immediately passes that error back to Claude. However, because third-party APIs use wildly different headers to communicate rate limits, Truto normalizes Amazon's proprietary limit info into standard IETF HTTP headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). 

This normalization ensures that the client application managing Claude understands exactly when it is safe to retry. The client orchestrator (e.g., LangGraph, AutoGen, or your custom application) is fully responsible for implementing exponential backoff. 

```mermaid
sequenceDiagram
    participant Claude as Claude Client
    participant Truto as Truto MCP Router
    participant Amazon as Amazon SP-API

    Claude->>Truto: Call list_all_amazon_vendor_central_df_orders
    Truto->>Amazon: Proxy Request (LWA Token)
    Amazon-->>Truto: 429 Too Many Requests (x-amzn-RateLimit-Limit)
    Note over Truto: Normalizes headers to standard IETF format
    Truto-->>Claude: Error (ratelimit-remaining: 0)
    Note over Claude: Client orchestrator handles backoff
    Claude->>Truto: Retry tool execution
    Truto->>Amazon: Proxy Request
    Amazon-->>Truto: 200 OK (JSON Payload)
    Truto-->>Claude: Tool Result Content
```

## Creating the Amazon Vendor Central MCP Server

Truto creates MCP servers scoped to a single integrated account. This means the resulting MCP server URL contains a cryptographic token securely tied to one specific Amazon Vendor Central tenant. The URL alone handles authentication for the MCP protocol.

You can generate this server via the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

1. Log into your Truto dashboard and navigate to the **Integrated Accounts** page.
2. Select your connected Amazon Vendor Central account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., restricting the server to only `read` methods or scoping it to specific tool tags).
6. Copy the generated MCP Server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4...`).

### Method 2: Via the Truto API

For teams embedding AI capabilities dynamically, you can provision MCP servers on the fly using a Truto API token.

**Request:**
```bash
curl -X POST https://api.truto.one/integrated-account/{account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Amazon Direct Fulfillment AI",
    "config": {
      "methods": ["read", "write"],
      "tags": ["direct_fulfillment", "orders"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

**Response:**
```json
{
  "id": "mcp_8f7e6d5c",
  "name": "Amazon Direct Fulfillment AI",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6...",
  "expires_at": "2026-12-31T23:59:59Z"
}
```

## Connecting the MCP Server to Claude

Once you have the [managed MCP URL](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/), connecting it to Claude requires zero additional infrastructure. 

### Method 1: Via the Claude Desktop UI

If you are using the consumer-facing Claude application:
1. Open Claude Desktop.
2. Navigate to **Settings -> Integrations -> Add MCP Server** (or **Settings -> Connectors -> Add** in ChatGPT).
3. Paste the Truto MCP URL into the configuration field.
4. Click **Add**.

Claude will immediately send an `initialize` JSON-RPC handshake to Truto. Truto responds with the server's capabilities and auto-generates the tool definitions dynamically based on the Amazon Vendor Central API documentation.

### Method 2: Via Manual Config File

For developer environments, you can route Claude through the official remote Server-Sent Events (SSE) client.

Edit your `claude_desktop_config.json` file:
```json
{
  "mcpServers": {
    "amazon-vendor-central": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}
```
Restart Claude Desktop. The model will automatically discover the Amazon Vendor Central tools.

## Hero Tools for Amazon Vendor Central

When Claude connects to the Truto MCP server, it gains access to the fully mapped SP-API. Here are the highest-leverage tools available for orchestrating supply chain and fulfillment operations.

### List Direct Fulfillment Orders
Retrieves a paginated list of purchase orders created during a specific time frame. This is the entry point for automated processing.
* **Tool Name:** `list_all_amazon_vendor_central_df_orders`
* **Required Parameters:** `createdAfter`, `createdBefore`
* **Usage Note:** Because this endpoint returns customer shipping details (PII), Claude must pass a `restricted_data_token` obtained via the restricted data token creation tool.

> "Fetch all direct fulfillment orders created in the last 24 hours. If you need a restricted data token to view PII, generate one first and apply it to this request."

### Create Direct Fulfillment Shipping Labels
Generates shipping labels for a specific purchase order and returns the label data and transaction reference.
* **Tool Name:** `create_a_amazon_vendor_central_df_shipping_label`
* **Required Parameters:** `purchase_order_number`, `sellingParty`, `shipFromParty`
* **Usage Note:** This is an asynchronous operation on Amazon's side. The LLM receives a transaction ID which can be polled later.

> "Generate shipping labels for purchase order AMZ-8910293. The selling party ID is 9912 and the ship-from party ID is WH-01. Return the transaction ID so we can track the label generation."

### Search Catalog Items
Search for Amazon catalog items by identifier (ASIN, UPC, EAN) or keyword to audit listings and verify product data.
* **Tool Name:** `list_all_amazon_vendor_central_catalog_items`
* **Required Parameters:** `marketplaceIds`
* **Usage Note:** Extremely strict rate limit (2 req/sec). Truto exposes `pageToken` for traversing subsequent pages seamlessly.

> "Search the US marketplace for catalog items matching the keyword 'ergonomic standing desk'. Extract the top 5 ASINs and their product dimensions."

### Submit Invoices
Submit one or more invoices to Amazon for shipped vendor orders to ensure timely payment.
* **Tool Name:** `create_a_amazon_vendor_central_invoice`
* **Required Parameters:** Standard SP-API invoice payload (invoice number, date, total amount, items).
* **Usage Note:** Used primarily in wholesale vendor workflows (non-DF) to trigger the accounts receivable cycle.

> "Create an invoice for purchase order V-90211. The invoice number is INV-2026-04, the total is $4,500, and it includes 100 units of ASIN B08F9...". 

### Update Direct Fulfillment Inventory
Submits inventory updates for a specified warehouse, ensuring Amazon has real-time visibility into available stock.
* **Tool Name:** `create_a_amazon_vendor_central_df_inventory_update`
* **Required Parameters:** `warehouse_id`, inventory payload.
* **Usage Note:** Crucial for preventing stockouts and protecting your vendor scorecard.

> "Update the inventory for warehouse WH-East. Set the available quantity for SKU DESK-PRO to 45 units and SKU CHAIR-LITE to 12 units."

To see the complete API inventory, including schemas, descriptions, and required fields for all endpoints, visit the [Amazon Vendor Central integration page](https://truto.one/integrations/detail/amazonvendor).

## Workflows in Action

Connecting an LLM to an MCP server goes beyond basic data retrieval. Here is how AI agents can orchestrate complex, multi-step operations using Truto's dynamically generated tools.

### Scenario 1: Automated Order Processing and Label Generation

**The Prompt:**
> "Check for any new direct fulfillment orders created in the last 6 hours. For every new order, acknowledge it and immediately generate a shipping label using warehouse WH-01."

**The Tool Execution Sequence:**
1. `create_a_amazon_vendor_central_restricted_data_token` - The agent requests an RDT authorized to access shipping details for direct fulfillment orders.
2. `list_all_amazon_vendor_central_df_orders` - The agent queries the API using the RDT and the timestamp filters to find new, unacknowledged orders.
3. `create_a_amazon_vendor_central_df_order_acknowledgement` - The agent iterates through the returned orders, sending an acceptance payload to Amazon.
4. `create_a_amazon_vendor_central_df_shipping_label` - The agent requests a label generation for each accepted order using the requested `shipFromParty` warehouse ID.

**The Result:**
The user receives a summary text block confirming exactly how many orders were found, acknowledged, and pushed to label generation, including the Amazon transaction IDs for tracking the label status.

```mermaid
flowchart TD
    A["Agent receives prompt"] --> B["Generate RDT<br>(create_a..._token)"]
    B --> C["Fetch new orders<br>(list_all..._df_orders)"]
    C --> D["Acknowledge orders<br>(create_a..._acknowledgement)"]
    D --> E["Request shipping labels<br>(create_a..._df_shipping_label)"]
    E --> F["Return summary to user"]
```

### Scenario 2: Catalog Audit and Restock Notification

**The Prompt:**
> "Look up our top 3 best-selling ASINs in the US marketplace. Check their current direct fulfillment inventory at warehouse WH-West. If any are below 20 units, draft an email to the logistics team to prioritize a restock."

**The Tool Execution Sequence:**
1. `get_single_amazon_vendor_central_catalog_item_by_id` - The agent queries Amazon for the metadata of the predefined top 3 ASINs to ensure they are active.
2. (Optional secondary tool) - The agent queries the inventory state via an internal inventory endpoint or custom method if supported, mapping the ASIN to the local SKU.
3. `create_a_amazon_vendor_central_df_inventory_update` - (If the agent was tasked with zeroing out out-of-stock items, it would call this). 
4. The agent compares the values, finds the low-stock items, and drafts the email in the chat window.

**The Result:**
The LLM bridges the gap between Amazon's live catalog data and the internal warehouse context, providing a ready-to-send operational alert.

## Security and Access Control

Exposing a global supply chain API to an LLM requires strict boundary setting. Truto's MCP servers provide multiple layers of configuration to limit the blast radius of AI agents.

*   **Method Filtering:** Limit an MCP server to strictly read-only operations by passing `methods: ["read"]` during creation. The server will only generate tools for `get` and `list` endpoints, completely eliminating the risk of an LLM accidentally creating or deleting inventory records.
*   **Tag Filtering:** Restrict the server to specific operational domains. By passing `tags: ["direct_fulfillment"]`, the server will ignore all catalog, reporting, and A+ content endpoints, exposing only the exact tools needed for order processing.
*   **Secondary Authentication (`require_api_token_auth`):** By default, the MCP URL acts as a bearer token. Enabling this flag forces the client to also pass a valid Truto API token in the `Authorization` header, preventing unauthorized usage if the URL leaks in local configuration files.
*   **Automatic Expiration (`expires_at`):** Set a TTL (Time To Live) on the MCP server. Truto's underlying durable state system schedules an automated cleanup task that destroys the server and revokes access at the exact millisecond requested, ideal for temporary agent workflows.

## Strategic Wrap-Up

Building a custom integration for Amazon Vendor Central means volunteering for years of maintenance debt. You must handle Restricted Data Tokens for PII, implement aggressive rate limit backoffs, and constantly monitor the SP-API for schema changes. 

By leveraging Truto's managed MCP server, you offload the entire infrastructure burden. Truto automatically generates the tool definitions, normalizes the rate limit headers, and provides a secure, single-URL entry point for Claude. This allows your engineering team to focus on building intelligent supply chain workflows, rather than fighting OAuth tokens and pagination cursors.

> Ready to give your AI agents secure, authenticated access to Amazon Vendor Central? Book a demo to see Truto's managed MCP architecture in action.
>
> [Talk to us](https://truto.one/book-a-demo/)