openbridge/amazon-ads-mcp repository overview

⁠Table of contents

• Where this fits in Kuudo⁠
• What are MCP tools?⁠
• What is Amazon Ads API MCP SDK?⁠
• Quick start⁠
• Installation⁠
• Configuration⁠ (auth, packages, profiles, regions)
• Downloading reports and exports⁠
• Example MCP client (Claude Desktop)⁠
• Context limits⁠
• Code mode⁠
• Tool audit⁠
• Background tasks⁠
• Frequently asked⁠
• Troubleshooting⁠
• Documentation map⁠

⁠Where this fits in Kuudo

This repository is the tool layer of a broader Amazon agent platform. Kuudo gives Amazon agents tools, knowledge, workflows, and a place to work. This repository is the tools.

Read this repository as one layer of that platform rather than as the whole of it. The operations below are what an agent can call; Skills are what it runs.

⁠What Are MCP Tools?

Think of MCP (Model Context Protocol) as a translator between an AI model and outside systems (like Amazon Ads). Each MCP tool is like a remote control button that tells the AI how to interact with Amazon Ads. Without MCP tools, the AI would have no idea how to “talk” to Amazon Ads.

With MCP tools:

• The AI knows the exact endpoints to call.
• The AI can request campaign reports, budgets, or targeting data safely.
• Everything is structured, so the AI doesn’t break things by making random guesses.

👉 In short: MCP tools = a safe, well-labeled toolkit that lets AI work with the Amazon Ads API⁠.

⁠🚀 What is Amazon Ads API MCP SDK?

The Amazon Ads API MCP SDK is an open-source implementation that provides a robust foundation for creating AI-powered advertising tools, chatbots, and automated services.

⁠✨ Key Features

• 🔌 MCP Integration: Full Model Context Protocol compliance for AI application integration
• 🌍 Multi-Region Support: NA, EU, and FE region endpoints with automatic routing
• 📊 Comprehensive API Coverage: Campaigns, profiles, reporting, DSP, AMC workflows, and more
• 📝 Type Safety: Full Pydantic model support with comprehensive type hints
• 🧪 Production Ready: Includes testing, validation, and error handling

⁠🎯 Use Cases

⁠Claude Desktop Integration

• Campaign Management: Ask Claude to create, update, or analyze campaigns
• Performance Insights: Get AI-powered analysis of your advertising performance
• Budget Optimization: Let Claude suggest budget adjustments based on performance
• Creative Testing: Get recommendations for ad creative improvements
• Reporting: Generate custom reports and insights on demand

⁠AI Applications

• Marketing Chatbots: Build conversational AI that can manage Amazon Ads campaigns
• Automated Reporting: AI-powered insights and performance analysis
• Smart Budget Management: Intelligent budget optimization using AI
• Creative Optimization: AI-driven ad creative testing and optimization

⁠Enterprise Services

• Marketing Automation Platforms: Integrate Amazon Ads into existing marketing tools
• Agency Management Systems: Multi-client, multi-account advertising management
• E-commerce Integrations: Connect Amazon Ads with e-commerce platforms
• Analytics Dashboards: Real-time advertising performance monitoring

⁠Developer Tools

• API Wrappers: Create custom SDKs for specific use cases
• Testing Frameworks: Automated testing for Amazon Ads integrations
• Development Tools: Local development and debugging utilities

⁠Why this Ads MCP is different

Other Amazon Ads MCPs do happy path. They fall apart the moment an agent makes a reasonable mistake and Amazon's Ads API has more reasonable mistakes than almost any other large API surface. The v1 reporting catalog uses a different vocabulary than v3. The docs are scattered across migration generations. The same field can have three plausible names depending on which tutorial an agent or human was trained on.

⁠You've felt this before

You know the symptoms even if you've never thought of them as a single problem:

• "Compacting conversation…" right when you were getting somewhere
• "Usage limit reached" mid-task, with nothing to show for the tokens
• "Context window exceeded" start over, re-explain everything
• The agent quietly forgetting the fix it figured out three turns ago
• Five tool calls, four of them retries, none of them progress
• Re-pasting the same error into the chat for the third time

That's not the model being dumb. That's the API surface burning context vague errors trigger thrashing, thrashing fills the window, the window fills and everything useful gets evicted. Anywhere from 4 to 12 round-trips for an agent: wrong field names, wrong body shape, wrong filter operator, wrong date placement, wrong advertiser-account format.

⁠Here, the wrong moves return the right move

This server is built around a different premise: the error surface is the documentation surface. Every failure is a teaching opportunity, and the server is engineered to make the next attempt smarter than the last one, for the same agent or the next one, without retraining, prompt updates, or memory tricks.

• The server tells you what went wrong, and why you got it wrong
• Every failure converts to a corrective action — the model just reads the hint and moves on
• A five-tool-call debugging arc collapses into a two-call corrected one
• The same mistake a week later doesn't re-burn context, because the validator, alias table, and deprecated-shape table are still right there
• No out-of-context tribal knowledge to forget

Every failure is cheaper than the last. Every agent learns from the same authoritative source. Every retry has direction. That compounding is what a smart agent solution looks like in practice.

⁠Everything is an edge case, you can help

We won't catch every edge case. Amazon's API surface is enormous, the migration history is messy, and real-world failures get more creative than anything anyone can anticipate. What we're committing to is the strategy that errors should teach, that documentation should live in the surfaces agents actually touch, that every wrong move should make the next move easier.

If you hit a failure where the envelope didn't help; vague hint, wrong suggestion, no hint at all, that's exactly the feedback we want. Open an issue, paste the envelope, tell us what you expected. The strategy is only as good as the cases it covers.

⁠Quick start

Prerequisites: Docker⁠ (recommended), Python 3.10+ if you run from source, and Amazon Ads API access⁠ (your own developer app or a partner such as Openbridge).

1. git clone https://github.com/KuudoAI/amazon-ads-mcp.git && cd amazon-ads-mcp
2. cp .env.example .env and add credentials (see Configuration⁠).
3. docker compose up -d
4. Connect your MCP client to http://localhost:<PORT>/mcp/ — .env.example sets PORT=9080 (override in .env if needed).

OAuth steps, client JSON samples, and a full variable reference: Configuration⁠ below, INSTALL.md⁠, and AGENTS.md⁠.

⁠📚 What Is Included In the Amazon Ads MCP?

The MCP server mirrors broad coverage of the Amazon Ads API surface. Each enabled package maps to a set of API operations. That includes Campaign Management (Amazon Ads API v1)⁠, Exports⁠, Amazon Marketing Cloud⁠, and many more.

Here is a representative list of the various Amazon API services in the MCP:

• Accounts
• Audiences
• Reporting
• Brand metrics
• Sponsored Products
• Sponsored Brands
• Sponsored Display
• Amazon DSP
• Amazon Attribution
• Recommendations & insights
• Creatives
• Change history
• Data provider
• Products
• Unified pre-moderation
• Moderation
• Amazon Marketing Stream
• Locations
• Exports
• Media Planning
• Amazon Ads API v1

⁠🧪 Amazon Ads API v1

The Amazon Ads API v1 represents a reimagined approach to the Amazon Ads API, built from the ground up to provide a seamless experience across all Amazon advertising products through a common model. One major benefit of this common model is improved compatibility with code generation tools such as client library generators.

To activate Ads API v1 packages, add them to your AMAZON_AD_API_PACKAGES environment variable:

# Example: Enable the merged Ads API v1 ALL surface
AMAZON_AD_API_PACKAGES="profiles,ads-api-v1-all"

For more information, see Amazon's Campaign Management Overview⁠.

⁠More than an MCP server

Everything above is the tool layer: the Amazon Ads operations an agent can call. Kuudo adds three layers around it, and a comparison that only counts operations misses them.

Kuudo provides higher-level workflows above the MCP tool layer through Skills. A Skill composes these operations into a repeatable Amazon procedure, grounds it with Atlas, and waits for a human before it changes anything.

⁠Installation

We recommend running Amazon Ads API MCP with 🐳 Docker⁠. Build the image from this repository (there is no supported docker pull for a third-party registry image here—use the Dockerfile and docker-compose.yaml in the repo).

For bespoke installs such as pip, source checkouts, custom virtualenvs, non-Docker deployments, or Code Mode extra handling, use the Installation Guide⁠. The README keeps the Docker quick path short; INSTALL.md has the full install matrix and verification steps.

git clone https://github.com/KuudoAI/amazon-ads-mcp.git
cd amazon-ads-mcp

Copy the environment template:

cp .env.example .env

Edit .env with your settings (including PORT if you change the default).

Start the server with Docker Compose (builds and tags amazon-ads-mcp:latest per docker-compose.yaml):

docker compose up -d

The server listens on the host port mapped from PORT in .env (.env.example uses 9080).

Check logs:

docker compose logs -f

Stop the server:

docker compose down

For verification, upgrading, developer setup, and non-Docker installation paths, see the Installation Guide⁠.

⁠Configuration

Operators / self-hosters: follow the steps below and your .env file. Chat users mostly interact via prompts once the server is connected; skim Advertiser Profiles & Regions⁠ for profile and region behavior.

Amazon Ads requires that all calls to the API are authorized. If you are not sure what this means, you should read the Amazon docs:

• Amazon Ads API onboarding overview: https://advertising.amazon.com/API/docs/en-us/guides/onboarding/overview⁠
• Getting started with the Amazon Ads API: https://advertising.amazon.com/API/docs/en-us/guides/get-started/overview⁠

There are three paths for connecting to the API;

1. Bring Your Own App (BYOA)
2. Use OpenBridge-managed authorizations
3. Use Kuudo-managed authorizations

⁠Bring Your Own Amazon Ads API App

If you have your own Amazon Ads API app, or want to create one, the process is detailed below.

⁠1. Register Your Application with Amazon

1. Go to the Amazon Developer Console⁠
2. Create or select your Login with Amazon application
3. Note your Client ID and Client Secret
4. Set your callback URL to "Allowed Return URLs". This must match the host and port of this MCP server’s HTTP listener (see PORT in .env; .env.example uses 9080):
   • For production: https://your-server.com/auth/callback
   • For local development: http://localhost:<PORT>/auth/callback (e.g. http://localhost:9080/auth/callback)

Once you have your app secured and approved by Amazon, you will need the client ID and secret:

# Amazon Ads API Credentials (required)
AMAZON_AD_API_CLIENT_ID="your-client-id"
AMAZON_AD_API_CLIENT_SECRET="your-client-secret"

Make sure these are in your .env file. Also, make sure you set your authorization method to direct in the same .env:

AUTH_METHOD=direct

⁠Complete OAuth Flow

To authorize your connection to Amazon, you need to complete an OAuth workflow as an end user. First, you need to set your region. Authorization occurs at the region level and not setting your region may cause a failure. The server will default to the na region. You can manually set the region with tool set_active_region.

• Tool: set_active_region
• Parameters: na | eu | fe

Example prompt: "Set my current region to eu"

⁠Step 1: Start OAuth

To connect to Amazon Ads API, you use an MCP tool to start your OAuth flow

• Tool: start_oauth_flow
• Example prompt: "Start my OAuth flow"

⁠Step 2: Redirect to Amazon Ads

In this example, you are prompted to click the link that will open a browser window and request approval at Amazon.

⁠Step 3: Approve Request

In the browser window, Amazon will prompt that you approve the request to connect.

⁠Step 4: Success

If all goes well, you will see a success response. You can close the browser window and go back to your client. If you see something else, attempt the process again and confirm all your configuration elements are correct

⁠Step 5: Confirmation

To confirm that your MCP server is connected to the Amazon Ads API, check your OAuth status

• Tool: check_oauth_status
• Example prompt: "Check my OAuth status"

You are ready to start interacting with the Amazon Ads API system!

⁠Partner Applications: Token Authentication

You can configure your client, like Claude, to use authentication by supplying a valid access token. This is most appropriate for service accounts, long-lived API keys, CI/CD, applications where authentication is managed separately, or other non-interactive authentication methods.

⁠Openbridge Partner App

As an Ads API Partner application provider, Openbridge offers a ready-to-go gateway to the Amazon Ads API. You log into your Openbridge account, provision a token, then set your token in your client config (see below).

First, set Openbridge as the auth method:

AUTH_METHOD=openbridge

That is it for the server config. To access the server, you need configure the client, like Claude Desktop, to pass the token directly. (see Example MCP Client: Connect Claude Desktop⁠)

⁠Authorized Amazon Accounts

Your Amazon authorizations reside in Openbridge. Your first step in your client is to request your current identities: "List my remote identities". Next, you would tell the MCP server to use one of these identities: "Set my remote identity to <>". You can then ask the MCP to List all of my Amazon Ad profiles linked to that account. If you do not see an advertiser listed, set a different identity.

⁠Kuudo Partner App

Kuudo can vend short-lived Amazon Ads credentials from organization-managed Amazon connections. Configure the server with a Kuudo M2M API key:

AUTH_METHOD=kuudo
KUUDO_API_BASE_URL=https://amazon-spapi-dev.kuudo.ai/
KUUDO_API_KEY=sk_xxxxxx
KUUDO_PROVIDER=amazon_ads

The API key requires the amazon-connections:read and amazon-tokens:vend scopes. Set KUUDO_REMOTE_IDENTITY_ID to select a default connection at startup, or use the identity tools to list and select a connection before calling Amazon Ads operations.

Public HTTP deployments must also configure MCP_INBOUND_TOKEN or trusted proxy HMAC authorization for MCP callers.

⁠Set Your Amazon Ads MCP Packages

To activate specific packages, set a comma-separated package list. For a streamlined default with unified Ads API v1 coverage:

• AMAZON_AD_API_PACKAGES="profiles,accounts-ads-accounts,reporting-version-3,amc-workflow,ads-api-v1-all"

Here is the list of tool packages available in the server:

• profiles
• test-account
• forecasts
• brand-stores-management
• campaign-manage
• accounts-manager-accounts
• accounts-ads-accounts
• accounts-portfolios
• accounts-billing
• accounts-account-budgets
• audiences-discovery
• reporting-version-3
• brand-benchmarks
• brand-metrics
• stores-analytics
• sponsored-products
• sp-suggested-keywords
• sponsored-brands-v4
• sponsored-brands-v3
• sponsored-display
• dsp-measurement
• dsp-advertisers
• dsp-audiences
• dsp-conversions
• dsp-target-kpi-recommendations
• amazon-attribution
• audience-insights
• partner-opportunities
• tactical-recommendations
• persona-builder
• creative-assets
• change-history
• data-provider-data
• products-metadata
• products-eligibility
• unified-pre-moderation-results
• moderation-results
• amazon-marketing-stream
• locations
• exports-snapshots
• marketing-mix-modeling
• reach-forecasting
• amc-administration
• amc-workflow
• amc-rule-audience
• amc-ad-audience
• ads-api-v1-sp (Beta)
• ads-api-v1-sb (Beta)
• ads-api-v1-dsp (Beta)
• ads-api-v1-sd (Beta)
• ads-api-v1-st (Beta)
• ads-api-v1-all
• ads-api-v1-beta (Beta)

You will note that some are broken up into smaller groupings. For example, Amazon Marketing Cloud has bundles; amc-ad-audience, amc-administration, amc-rule-audience, and amc-workflow. This is done to create efficiencies and optimizations that reduce context limits in many AI clients.

⁠Understanding Amazon Ads MCP Tools

Amazon Ads MCP tools have prefixes (like cm_ for Campaign Management or amc_ for Amazon Marketing Cloud) to help organize the specific Ads API operation.

Example prefixes:

• cm_ → campaign/advertising APIs
• amc_ → AMC-related APIs
• dsp_ → DSP APIs
• sd_ → Sponsored Display
• ams_ → Amazon Marketing Stream
• spv1_ → Sponsored Products v1 (Beta)
• sbv1_ → Sponsored Brands v1 (Beta)
• dspv1_ → Amazon DSP v1 (Beta)
• sdv1_ → Sponsored Display v1 (Beta)
• stv1_ → Sponsored Television v1 (Beta)

This will translate into collections of tools that align with the API operations that are available:

Campaign Management (cm_)

• cm_QueryCampaign — Query campaigns
• cm_CreateCampaign — Create campaign
• cm_UpdateCampaign — Update campaign
• cm_DeleteCampaign — Delete campaign
• cm_QueryAdGroup — Query ad groups

Sponsored Products (sp_)

• sp_listProductAds — List product ads
• sp_createKeywords — Create keywords
• sp_updateBids — Update keyword bids
• sp_getNegativeKeywords — Get negative keywords

AMC Workflows (amc_)

• amc_listWorkflows — List AMC workflows
• amc_executeWorkflow — Run workflow
• amc_getWorkflowStatus — Check workflow status

Users would see tools like:

• "List my Amazon Ads campaigns"
  → Claude uses: cm_QueryCampaign

• "Create an AMC workflow"
  → Claude uses tools such as amc_executeWorkflow (after discovery; exact names depend on your enabled packages)

• "Export my sponsored products ads data" → Claude uses: export_createAdExport

Continue reading the full README on main⁠.