Amazon Ads & Claude Code: The Ultimate MCP Setup Guide for Sellers

TL;DR

What exactly does this setup do for my Amazon Ads?

It acts as a translator, allowing you to manage and optimize your Amazon PPC campaigns using plain English commands in Claude Code, bypassing the need to manually click through the Campaign Manager.

Can the AI see my FBA inventory levels or true profit margins?

No, and this is its biggest risk. The AI exclusively sees advertising data. It has zero visibility into your stock levels, COGS, or Buy Box status, meaning it could aggressively spend on an ASIN that is unprofitable or about to run out of stock.

Do I need to know how to code to set this up?

No, but it is highly technical. You don’t need to write custom Python or JavaScript, but you must be comfortable following strict technical instructions, using a command-line interface (Terminal), generating API keys, and running Docker containers.

Is this integration free to use?

The KuudoAI server infrastructure and the Amazon Developer account are free. However, you will have to pay Anthropic’s usage-based API fees for the processing power Claude Code uses, in addition to your actual Amazon ad spend.

Picture this: It is 11:30 PM on a Tuesday. You are staring at a blindingly bright Campaign Manager screen, manually adjusting bids across forty-seven different Sponsored Products campaigns. You have three spreadsheets open, cross-referencing true ACoS, CPCs, and search term reports, hoping you do not accidentally pause a keyword that is secretly driving your organic rank. This has been the grueling, labor-intensive reality of Amazon PPC management for years. 

But what if you could bypass the clicks and simply type a command? Imagine typing, “Claude, find every exact match keyword across my account that burned through $100 last month with zero sales, and pause them,” and watching it happen in three seconds. 

This is where Amazon advertising workflows are heading in 2026. MCP servers now connect with AI models like Claude, which changes how sellers interact with Amazon Ads data. By bridging the gap between powerful AI agents like Claude Code and the raw data of your Amazon Ads account, you can turn natural language into the ultimate PPC automation tool. 

However, this technological leap comes with massive caveats. While the speed of execution is unprecedented, the system requires a rigid, highly technical setup, and it has critical blind spots that can bankrupt a careless seller. In this comprehensive, fully fleshed-out guide, we are going to break down exactly what the Amazon Ads MCP server is, walk you through the complete step-by-step installation to connect it with Claude Code, and show you how to leverage this power while keeping your profitability strictly intact. 

If you want to stop clicking buttons and start directing a highly capable AI assistant to manage your advertising at scale, you are in exactly the right place. Let’s dive deep into the setup. 

The Paradigm Shift: Why the MCP Server Changes Everything

To fully appreciate why connecting Claude Code to your Amazon Ads account is such a monumental operational shift, you have to understand the historical friction of Amazon APIs. Historically, if you wanted to automate your Amazon advertising beyond the basic rule-based console features, you had to hire an expensive development team to build a custom integration, or you had to pay for rigid third-party software that had already done the heavy lifting. 

Even then, those software solutions were often inflexible. They operated on predefined algorithmic rules. If you wanted the software to execute a highly nuanced, context-specific strategy outside of its programmed parameters, you were out of luck. 

The Model Context Protocol (MCP) changes how this architecture works. MCP was originally developed by Anthropic to standardize how AI models connect to external data sources.  

In simple terms, it acts like a translator between the AI and Amazon’s advertising APIs.  

When you set up the Amazon Ads MCP server, you effectively hand the execution keys over to Claude Code. 

Instead of writing complex Python scripts to authenticate, pull data, parse JSON files, and push bid adjustments, you install the server, connect it, and issue commands in plain English. The server translates your natural language prompt into structured, perfectly formatted API calls that Amazon’s internal systems natively understand. 

The End of “Reasoning Overload” 

During early AI testing in the e-commerce space, engineers quickly discovered that large language models left to their own devices would often hallucinate API endpoints or pull massive amounts of irrelevant, deprecated data. Without strict guardrails, an AI might try to pull three years of Amazon Marketing Cloud data just to answer a simple question about yesterday’s Sponsored Brands spend. 

The Amazon Ads MCP server solves this “reasoning overload” by providing a strict instruction manual and toolset for the AI. It limits Claude Code to approved domain model standards. It pre-packages complex, multi-step workflows into single, actionable tools. For example, creating a Sponsored Products campaign usually requires three distinct API calls: one for the campaign, one for the ad group, and one for the targeting. The MCP server bundles these into a single action. You give the command once, and the server natively handles the chaining of those operations. 

The Danger of AI Speed Without Business Context

Before we jump into the terminal commands and Docker containers, you need to understand a massive structural reality of AI-managed advertising. Your experience with this tool will be sharply divided into two distinct categories: rapid execution and limited context. 

When you tell Claude Code to do something, the results are legitimately terrifying in their speed.  

That speed changes how sellers manage campaigns. 

Creating a new campaign, applying budgets, setting up semantic ad groups, and launching across North America takes one prompt and about three seconds of processing time. 

However, there is an important limitation sellers should understand: The basic Amazon Ads MCP server is completely blind to your actual business health. The server connects your AI exclusively to advertising data. 

It has absolutely zero visibility into several business signals that experienced sellers monitor daily: 

• Your Real-Time Inventory: Claude Code will happily crank up your bids and double your daily budget on an ASIN that only has eight days of stock left at FBA. It does not know you are about to stock out. 

• Your True Profitability: The AI sees a 15% ACoS and thinks you are crushing it. It does not know that after Amazon’s FBA fee hikes, inbound placement fees, and your specific COGS, that product is actually losing you money on every sale. 

• The Buy Box Dynamics: The AI might continue aggressive bidding on a listing where a hijacker just stole the Buy Box, effectively funding traffic for a competitor. 

Amazon built the infrastructure, but the decision-making layer still depends on the user. Ad decisions are fundamentally business decisions. When you use Claude Code via the basic Amazon Ads MCP server, you are giving an AI a high-performance sports car but putting a blindfold over its eyes. That speed sounds great, but it also creates risk. 

This is exactly why sophisticated sellers utilize platforms like SellerMetrics. SellerMetrics bridges that gap, aggregating your advertising data, real-time FBA inventory, and exact profit margins into one cohesive picture. Speed is completely useless, and often incredibly expensive, if it lacks an overarching business context. You should use Claude for rapid execution, but always anchor your strategy in true profitability metrics. 

The Ultimate Step-by-Step Setup Guide: Amazon Ads MCP & Claude Code

Setting up the Amazon Ads MCP server is a highly technical process. It requires command-line interface (CLI) execution, API credential management, and local container hosting. We will be using the KuudoAI/amazon_ads_mcp open-source server (MIT License). 

At first glance the setup may look intimidating, but most of the steps simply involve connecting existing tools together. 

Please follow these steps meticulously. Skipping a step or misconfiguring a redirect URI will result in authentication failures. 

Many sellers actually get stuck during the initial API approval step, so patience here helps. 

Phase 1: Meeting the Prerequisites and Gaining API Access 

Before touching any code, you must ensure your local environment and Amazon accounts are prepped. 

You will need a Mac, Windows, or Linux machine. You must also have an Amazon Seller or Vendor account with active advertising campaigns running. Amazon will not grant API access to empty accounts. Finally, ensure you have the Claude Code (Anthropic CLI) application natively installed on your machine. 

Creating Your Developer Account & App: 

Troubleshooting Note: If your application is rejected, the most common reason is a lack of active ad spend. Make sure campaigns are running and reapply with highly detailed notes about your intended MCP use case.

Phase 2: Configuring Your LWA Security Profile 

Login with Amazon (LWA) is the secure protocol the MCP server uses to authenticate your identity with Amazon’s advertising API. 

Creating the Profile: 

Extracting Credentials: 

Many sellers get stuck during this part of the setup, usually because of a redirect URL mismatch. Double-checking that value early can save a lot of troubleshooting later. 

Crucial Warning: If you get an “Invalid redirect URI” error later during setup, it is because the URL you pasted here does not perfectly match what the MCP server expects. For local setups, it must be http://localhost:8000/auth/callback. 

Linking the Profile: Finally, you must link this LWA profile to your Ads app. Go back to your Amazon Advertising Console, navigate to your API settings, find the LWA credentials section, and select the security profile you just built. Do not look for this in the developer console; it is inside your actual Ads console. 

Phase 3: Installing Docker Desktop 

The MCP server runs inside an isolated container to prevent dependency conflicts on your computer. We use Docker for this. If you already work with development tools, this part should feel familiar. 

• For Mac Users: Go to docker.com, download the Apple Silicon or Intel .dmg file. Drag it to Applications, launch it, and wait for the whale icon in your menu bar to stop animating, signaling the engine is running. 
• For Windows Users: Download the installer from docker.com. When prompted, ensure you enable WSL 2 (Windows Subsystem for Linux), as it is highly recommended for performance. Restart your PC and launch the app. 
• For Linux Users (Ubuntu/Debian): Open your terminal and run the standard installation commands to update packages and install docker.io and docker-compose. Start the service (sudo systemctl start docker) and add your user to the docker group (sudo usermod -aG docker $USER). Log out and back in. 

Verify your installation by running docker --version and docker-compose --version in your terminal. 

Once Docker is installed and running correctly, the rest of the setup becomes much more straightforward. 

Phase 4: Cloning the Repository and Environment Configuration 

Now we pull the actual server code to your machine. 

Open your terminal and clone the official GitHub repository: 

Bash 

git clone https://github.com/KuudoAI/amazon_ads_mcp.git 

cd amazon_ads_mcp 

Next, create your environment variables file by copying the example template: 

Bash 

cp .env.example .env 

Open this .env file in a text editor like Nano or VS Code (nano .env or code .env). You need to configure the following exact values: 

Server Settings: 

TRANSPORT=http 

HOST=0.0.0.0 

PORT=9080 

LOG_LEVEL=INFO 

Authentication: 

AUTH_METHOD=direct 

AMAZON_AD_API_CLIENT_ID=”your-client-id-here” 

AMAZON_AD_API_CLIENT_SECRET=”your-client-secret-here” 

(Replace the placeholder text with the exact credentials you pulled from LWA in Phase 2. Keep the quotation marks.) 

Region Selection: You must define your primary advertising region. Use na for North America (US/CA/MX/BR), eu for Europe, or fe for the Far East. 

API Tool Packages: Control what the AI is allowed to do. Start with this recommended baseline: 

AMAZON_AD_API_PACKAGES=”profiles, sponsored-products, reporting-version-3, brand-metrics, products-metadata” 

Phase 5: Booting Up the Server and Connecting Claude 

With your .env configured, start the server using Docker Compose: 

Bash 

docker-compose up -d 

This command builds the Docker image (which takes 2-5 minutes the first time) and starts the server silently in the background, exposing it on http://localhost:9080. You can verify it is running by typing docker-compose logs -f, which should return a success message indicating the server started. Hit Ctrl+C to exit the logs. 

Connecting to Claude Code: Now, we must tell Claude where to find this server. Edit your Claude MCP configuration file: 

Bash 

nano ~/.claude/mcp.json 

Add the Amazon Ads server block to the JSON file: 

JSON 

{ 

  “mcpServers”: { 

    “amazon-ads”: { 

      “type”: “streamable-http”, 

      “url”: “http://localhost:9080/mcp”, 

      “headers”: {} 

    } 

  } 

} 

Close and completely reopen your Claude Code application to ensure the changes are registered. You should now see amazon-ads listed as an active tool. 

Phase 6: Executing the OAuth Flow and Profile Selection 

The server is running, and Claude sees it, but the AI does not have permission to touch your data yet. We must execute an OAuth flow. Once the connection works, the real advantage becomes obvious. 

Open Claude Code and issue these exact conversational prompts: 

Setting Your Active Profile: Amazon Ads operates on “profiles,” where each profile represents one account in one specific marketplace (e.g., your US store is a different profile than your Canada store). 

Ask Claude: “List my Amazon Ads profiles”. The AI will return a list showing the Profile ID, Type (seller/vendor), and Account Name. 

Find the Profile ID you want to manage and tell Claude: “Set active profile to [YOUR_PROFILE_ID]”. You absolutely must set an active profile before the AI can run any reporting or campaign management tools.

At this point the server should already be running, so the next steps are mainly about confirming everything works correctly. 

Phase 7: Validating Your Setup and Expanding Capabilities 

Let us verify everything is fully operational. Try giving Claude a few test prompts: 

• “List my sponsored products campaigns” 
• “Show me my brand metrics” 
• “Show me my top performing keywords” 

If Claude returns formatted data directly in your terminal, congratulations. You have successfully integrated an AI agent with your Amazon Ads backend. 

Understanding Packages and Prefixes: As you get more advanced, you can expand what Claude is allowed to do by adding more packages to the AMAZON_AD_API_PACKAGES variable in your .env file. 

Available packages include: 

• sponsored-brands-v4: For Sponsored Brands operations. 
• sponsored-display: For Sponsored Display operations. 
• change-history: Creates an audit trail of your campaign changes. 
• amc-workflow: For complex Amazon Marketing Cloud queries. 
• (Remember: if you add packages, you must restart the server using docker-compose down && docker-compose up -d). 

When you ask Claude what tools it has, you will notice they use specific prefixes. For example, cp_ is for campaign operations, sp_ is specifically for Sponsored Products, and amc_ is for Amazon Marketing Cloud. 

Phase 8: Async Reporting and Token Persistence 

Handling Reports: Because Amazon’s reporting API is asynchronous, downloading large datasets requires a specific workflow. When you ask Claude for a massive report, the server requests it and downloads it server-side. 

To access it, tell Claude: “List my downloads”. Claude will find the file. Then ask: “Get download URL for report [Name]”. You can then download that file via your browser or by using a curl command directly in your terminal pointing to http://localhost:9080/downloads/reports/async/.... 

Keeping the AI Logged In: By default, your OAuth tokens only live in your computer’s temporary memory. If you restart Docker, you have to log in all over again. 

To fix this, you can enable Token Persistence. Open your .env file and add: 

AMAZON_ADS_TOKEN_PERSIST=true 

For local development, this auto-generates a machine-specific encryption key to safely store your login state on your hard drive. If you are moving this to a production cloud server, you should generate a secure Fernet key via Python (python3 -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())") and explicitly define AMAZON_ADS_ENCRYPTION_KEY in your .env file. Never commit your .env file to a public GitHub repo!. 

Phase 9: Server Management and Troubleshooting Guide 

Working with Docker and APIs means you will inevitably run into snags. Here is how to handle the most common issues: 

Server / Docker Issues: 

• “Port 9080 already in use”: Another app is using this port. Change the PORT variable in your .env file to 9081 and update your mcp.json file to match.
• Container exits immediately: You likely have a typo in your .env file. Run docker-compose logs to see the exact error. 
• To check your server status, run docker-compose ps. To restart everything gracefully, run docker-compose down && docker-compose up -d. 

Authentication Issues: 

• “Invalid client_id” in browser: You copied your ID incorrectly into the .env file. Ensure it includes the full string, including the amzn1... portion. 
• “Invalid redirect_uri”: The callback URL you put in the Amazon Developer Console does not exactly match http://localhost:8000/auth/callback. 
• Browser says success, but Claude says “not authenticated”: You forgot to link your LWA security profile to your Ads API application in the advertising console. 

The Nuclear Option: If absolutely everything is broken and you want to start from scratch, you can obliterate the setup and reinstall. Run: 

Bash 

docker-compose down -v 

docker rmi amazon-ads-mcp:latest 

cd .. 

rm -rf amazon_ads_mcp 

Then simply re-clone the repo and start over. 

Advanced AI Prompting Workflows for Sellers

Now that your infrastructure is flawlessly connected, you can stop acting like a data-entry clerk and start operating like an elite fractional CMO. Because the MCP server bundles API calls, you can feed Claude highly descriptive instructions. 

Here are three advanced workflows that you can execute today: 

1. The “Bleeder” Keyword Purge 

Instead of manually sifting through search term reports, instruct Claude to act as a ruthless auditor. The Prompt: 

“Claude, I need to clean up wasted spend. Please request a 30-day performance report for all Sponsored Products campaigns. Identify any exact match keywords that have accumulated more than $40 in spend with exactly 0 sales. Output a list of these keywords for my review. Wait for my confirmation, and if I say ‘approved’, proceed to pause every single one of those keywords across the account.” 

2. Rapid Cross-Border Campaign Cloning 

Expanding an established brand to Canada or Mexico used to require hours of repetitive, mind-numbing data entry. The Prompt: 

“Claude, pull the complete structure (budgets, ad groups, ASINs) for the US campaign named ‘SP_GarlicPress_Exact’. Once you have it, use the Amazon Ads MCP server to recreate this exact campaign structure in my Canadian (CA) profile. Convert the daily budget from $100 USD to the equivalent CAD amount. Set default keyword bids to $0.80 CAD. Name the new campaign ‘CA_SP_GarlicPress_Exact’.” 

3. Automated ASIN Defense Perimeter 

Protecting your own real estate on Amazon is fundamental to keeping competitors off your product pages. The Prompt: 

“Claude, pull a list of all active ASINs in my account. Create a new Sponsored Display campaign named ‘SD_Defensive_Targeting’. Set the daily budget to $50. Create an ad group that targets all of my own ASINs. Set the bid to $1.50 to ensure my products dominate the ad placements directly under my own Buy Boxes.” 

Conclusion: Adapt, Automate, and Anchor in Data

The rollout of the Amazon Ads MCP Server and its integration with Claude Code represent a structural shift in how Amazon advertising fundamentally operates. We are rapidly moving away from an era of manual spreadsheet optimization into an era of programmatic, natural-language command execution. 

Sellers who ignore these workflows may simply end up working slower than competitors who automate tasks. While you are spending three hours on a Monday morning clicking through Seller Central tabs, your competitor is executing account-wide optimizations in forty-five seconds via a terminal prompt. 

However, speed without strategy is a fast track to burned capital. Use Claude Code to execute the heavy lifting but rely on comprehensive analytics suites like SellerMetrics to provide the crucial business context—inventory health, true COGS, and real margins—that the AI fundamentally lacks.

In practice, this changes how sellers operate their advertising accounts. 

The Amazon Ads API is officially open to your commands. It is time to step into the future of e-commerce automation. 

Would you like me to help you draft your first custom Claude Code prompt tailored specifically to your current ACoS goals? Let me know below!

FAQ: Amazon Ads & Claude Code: MCP Setup Guide for Sellers