Connect Amazon Seller Central to Claude: Automate Orders and Shipping

If your team needs to connect Amazon Seller Central to Claude to automate order fulfillment, manage FBA inventory, or orchestrate complex shipping logistics, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Amazon's Selling Partner API (SP-API). You can either build and maintain this sprawling 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 /connect-amazon-seller-central-to-chatgpt-manage-fba-and-inventory/ or explore our broader architectural overview on /connect-amazon-seller-central-to-ai-agents-sync-awd-and-financials/.

Giving a Large Language Model (LLM) read and write access to Amazon Seller Central is a serious engineering challenge. You have to handle rigorous OAuth token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Amazon's infamously strict data protection policies. Every time Amazon deprecates a resource or updates its FBA workflow requirements, 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 Amazon Seller Central, connect it natively to Claude Desktop, and execute complex e-commerce workflows using natural language.

The Engineering Reality of the Amazon Seller Central 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 specialized B2B APIs is painful. Amazon Seller Central is built to manage massive global supply chains, strict compliance requirements, and highly sensitive customer data. Its API reflects that immense complexity.

If you decide to build a custom Amazon Seller Central MCP server, here are the specific integration challenges you will face:

Restricted Data Tokens (RDT) and PII Access Amazon strictly enforces Data Protection Policies (DPP). Standard API tokens cannot access Personally Identifiable Information (PII) like buyer names or shipping addresses. If an LLM needs to fulfill an MFN (Merchant Fulfillment Network) order, it must first call a specific endpoint to generate a Restricted Data Token (RDT) targeted at the exact API path and data elements it wants to access, and then pass that RDT into the subsequent order query. Building this two-step auth orchestration into a standard MCP server requires complex context passing.

Asynchronous Reporting and Data Kiosks You cannot simply query "all inventory across all time" synchronously. Amazon relies heavily on asynchronous operations for large datasets. You must request a report, poll for its completion, and then retrieve a signed URL to download the document. Presenting this to an LLM requires abstracting the polling and document parsing logic so the agent doesn't hang or hallucinate while waiting for a report to generate.

Complex Pagination and Idempotency Amazon utilizes varying pagination schemes across its endpoints. Some endpoints use nextToken, while others use paginationToken. Furthermore, mutating endpoints (like creating sandbox inventory or confirming inbound shipments) require unique idempotency tokens (like x-amzn-idempotency-token) generated on a per-request basis. An LLM has no inherent mechanism to generate strict UUIDs or track disparate cursor keys without a highly opinionated middleware layer.

Creating the Amazon Seller Central MCP Server

Instead of building this middleware from scratch, Truto dynamically derives MCP tools directly from the underlying integration's resources and documentation. You can generate a self-contained, authenticated MCP server URL in minutes.

Before you start, ensure you have connected an Amazon Seller Central account in your Truto environment.

Method 1: Via the Truto UI

This is the fastest way to get an MCP server up and running for local testing.

1. Navigate to the Integrated Accounts page in your Truto dashboard.
2. Select your connected Amazon Seller Central account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., restricting access to only read operations or specific tags).
6. Copy the generated MCP server URL. Keep this secure - it contains the cryptographic token required for access.

Method 2: Via the Truto API

For production workflows, you will want to generate MCP servers programmatically. This ensures you can dynamically provision LLM access for specific users or automated jobs.

Send a POST request to /integrated-account/:id/mcp:

const response = await fetch('https://api.truto.one/integrated-account/<amazon-account-id>/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_TRUTO_API_TOKEN',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Amazon Fulfillment Agent",
    config: {
      methods: ["read", "write"], // Filter operations
      require_api_token_auth: false
    },
    expires_at: "2026-12-31T23:59:59Z"
  })
});
 
const data = await response.json();
console.log(data.url); // Your secure MCP server URL

A Critical Note on Rate Limits

Amazon SP-API enforces strict rate limits based on a leaky bucket algorithm. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Amazon API returns an HTTP 429 Too Many Requests, Truto passes that exact error back to the caller.

To help your LLM framework or agent orchestration layer handle this, Truto normalizes upstream rate limit info into standardized headers per the IETF spec:

• ratelimit-limit
• ratelimit-remaining
• ratelimit-reset

The caller (your agent framework or application) is strictly responsible for implementing retry logic and backoff. Do not design workflows assuming the MCP server will absorb rate limit errors.

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, connecting it to Claude takes seconds. Because the Truto MCP server is fully self-contained, you do not need to configure OAuth or API keys inside Claude.

Method A: Via the Claude UI

If you are using the Claude Desktop application or an enterprise web interface that supports UI-based configuration:

1. Open Claude and navigate to Settings.
2. Go to Integrations -> Add MCP Server (or Custom Connectors).
3. Paste the Truto MCP server URL you generated earlier.
4. Click Add. Claude will instantly execute a handshake, pull the available tools, and make them available for conversation.

Method B: Via Manual Config File

For developers managing Claude Desktop locally, you can modify the configuration file directly. This uses the standard Server-Sent Events (SSE) transport approach.

Locate your claude_desktop_config.json file (typically found in ~/Library/Application Support/Claude/ on macOS or %APPDATA%\Claude\ on Windows) and add your Truto MCP URL:

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

Restart Claude Desktop. The Amazon Seller Central tools will now be available.

Hero Tools for Amazon Seller Central

Truto exposes hundreds of endpoints for Amazon Seller Central. Here are 6 high-leverage hero tools that empower AI agents to manage sophisticated supply chain and fulfillment operations.

Create an FBA Inbound Plan

create_a_amazon_seller_central_fba_inbound_plan

This tool allows the agent to initiate the complex process of sending inventory into Amazon's fulfillment network. It requires the source address and the specific items you intend to ship.

"Review our current stock levels for MSKU 'premium-widget-01'. If we have fewer than 50 units available, create a new FBA inbound plan to send 200 units from our primary Seattle warehouse to the US marketplace."

List FBA Inventory Summaries

list_all_amazon_seller_central_fba_inventory_summaries

An essential read operation for monitoring stock levels. Truto automatically manages the nextToken logic, allowing the LLM to paginate through inventory records seamlessly.

"Pull the latest FBA inventory summaries for the US marketplace. Identify any SKUs where the fulfillable quantity is zero but there is inbound quantity expected."

Generate Restricted Data Tokens

create_a_amazon_seller_central_restricted_data_token

This is the critical security tool for accessing PII. If an agent needs to see buyer addresses or names to fulfill an order, it must call this tool first, specifying the restricted resources, and use the returned token in subsequent calls.

"We need to process the shipping label for order ID 111-2222222-3333333. Generate a Restricted Data Token for the order shipment path, then fetch the order details so we can see the buyer's delivery address."

Create an MFN Shipment

create_a_amazon_seller_central_mfn_shipment

Allows the agent to purchase shipping services for Merchant Fulfillment Network (MFN) orders. It handles the payload mapping for package dimensions, weights, and service IDs.

"Using the shipping service ID provided by the eligible services tool, create an MFN shipment for order 114-5555555-6666666 using a standard 10x10x5 box weighing 2 pounds."

Search Amazon Orders

list_all_amazon_seller_central_orders

Fetches orders created or updated within a specified timeframe. If called without an RDT, it returns anonymized data. If called with an RDT, it returns full buyer details.

"List all orders created in the last 24 hours that are currently in an 'Unshipped' status. Group them by standard vs expedited shipping speed."

Manage AWD Outbound Orders

list_all_amazon_seller_central_awd_outbound_orders

For merchants utilizing Amazon Warehousing & Distribution (AWD), this tool retrieves outbound orders moving from upstream storage into the active fulfillment network.

"Check the status of all AWD outbound orders for this week. Flag any orders that are currently sitting in an 'INELIGIBLE' state so we can review the validation errors."

To view the complete inventory of Amazon Seller Central tools, including endpoint schemas and rate limits, visit the Amazon Seller Central integration page.

Workflows in Action

Individual tools are useful, but the real power of MCP emerges when an LLM orchestrates multi-step workflows. Here is how Claude uses these tools to solve real e-commerce problems.

Workflow 1: FBA Inventory Audit and Restock Planning

Managing FBA inventory requires constantly balancing current stock against inbound shipments to avoid stockouts without incurring long-term storage fees.

"Run a complete audit of our FBA inventory. Find any items where the fulfillable quantity is below 20. For those items, check if there are any active FBA inbound shipments. If there are no inbound shipments, generate a draft inbound plan to restock 100 units of each low-stock item from our origin address."

1. list_all_amazon_seller_central_fba_inventory_summaries: Claude fetches current stock levels, identifying MSKUs with < 20 fulfillable units.
2. list_all_amazon_seller_central_fba_inbound_shipments: Claude checks if any of the low-stock items already have active shipments en route.
3. create_a_amazon_seller_central_fba_inbound_plan: For items with no active shipments, Claude submits the JSON payload to draft a new inbound plan.

The user receives a concise summary of the inventory audit and a confirmation that a new FBA inbound plan has been successfully staged in Seller Central for final approval.

Workflow 2: Secure MFN Order Fulfillment

Handling Merchant Fulfilled Network orders requires secure handling of PII and multi-step logistics coordination.

"Process fulfillment for the oldest unshipped MFN order. Get the necessary secure access to see the shipping address, find the cheapest eligible shipping service for a 12x8x4 package weighing 3lbs, and purchase the shipping label."

sequenceDiagram
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant SPAPI as Amazon SP-API
    Claude->>MCP: Call create_a_amazon_seller_central_restricted_data_token
    MCP->>SPAPI: POST /tokens/2021-03-01/restrictedDataToken
    SPAPI-->>MCP: Returns RDT String
    MCP-->>Claude: Passes RDT securely
    Claude->>MCP: Call get_single_amazon_seller_central_order_by_id (with RDT)
    MCP->>SPAPI: GET /orders/v0/orders/{id}
    SPAPI-->>MCP: Returns Order with PII
    MCP-->>Claude: Analyzes Address Data
    Claude->>MCP: Call create_a_amazon_seller_central_mfn_eligible_shipping_service
    MCP->>SPAPI: POST /mfn/v0/eligibleShippingServices
    SPAPI-->>MCP: Returns Rates
    MCP-->>Claude: Selects Cheapest Rate
    Claude->>MCP: Call create_a_amazon_seller_central_mfn_shipment
    MCP->>SPAPI: POST /mfn/v0/shipments
    SPAPI-->>MCP: Returns Label
    MCP-->>Claude: Completes Fulfillment

1. create_a_amazon_seller_central_restricted_data_token: Claude requests an RDT for the specific order path to gain PII access.
2. get_single_amazon_seller_central_order_by_id: Claude queries the order using the RDT to extract the shipping address.
3. create_a_amazon_seller_central_mfn_eligible_shipping_service: Claude passes the address and package dimensions to Amazon to get rate quotes.
4. create_a_amazon_seller_central_mfn_shipment: Claude selects the cheapest rate and purchases the shipping label.

The user receives confirmation of the shipped order, along with the tracking number and a link to print the generated label, without ever manually opening Seller Central.

Security and Access Control

Giving an AI agent access to an ecosystem as critical as Amazon Seller Central requires strict governance. Truto MCP servers provide multiple layers of security to ensure agents only take authorized actions.

• Method Filtering: You can strictly limit the MCP server to specific operations. By passing config.methods: ["read"] during creation, the LLM will only see get and list tools. It becomes physically impossible for the agent to create orders, update shipments, or modify pricing.
• Tag Filtering: If you only want an agent to manage inventory but not touch messaging or financials, you can apply tag filters. The server will only expose tools for resources matching those specific tags.
• Enforced API Token Auth: By default, possessing the MCP URL grants access. By setting require_api_token_auth: true, you force the calling client to also provide a valid Truto API token via a Bearer header. This protects URLs that might be exposed in configuration files or logs.
• Time-Limited Access: You can define an expires_at timestamp. Once reached, the underlying token is purged from distributed KV storage and database records, instantly cutting off the LLM's access to Amazon Seller Central.

Automate Shipping, Not Infrastructure

Integrating AI into your e-commerce operations shouldn't require your engineering team to become experts in Amazon's SP-API authentication lifecycle, PII restrictions, and pagination quirks. By leveraging Truto's managed MCP servers, you eliminate the integration boilerplate entirely.

Your engineers can focus on building intelligent prompts and multi-agent orchestration, while Truto handles the translation layer between Claude's intent and Amazon's REST endpoints. Stop wrestling with API infrastructure and start deploying AI agents that actually drive revenue.