# Amazon Ads Mcp

> Amazon Ads MCP - Model Context Protocol server for Amazon Advertising API

- **Type:** MCP server
- **Install:** `agentstack add mcp-kuudoai-amazon-ads-mcp`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [KuudoAI](https://agentstack.voostack.com/s/kuudoai)
- **Installs:** 0
- **Category:** [Integrations](https://agentstack.voostack.com/c/integrations)
- **Latest version:** 0.2.6
- **License:** MIT
- **Upstream author:** [KuudoAI](https://github.com/KuudoAI)
- **Source:** https://github.com/KuudoAI/amazon_ads_mcp
- **Website:** https://www.openbridge.com

## Install

```sh
agentstack add mcp-kuudoai-amazon-ads-mcp
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Amazon Ads API MCP SDK

**Build AI-powered advertising applications with the Model Context Protocol (MCP) SDK for Amazon Advertising API**

*Made with ❤️ + ☕ by [Openbridge](https://www.openbridge.com/)*

[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
[](https://github.com/KuudoAI/amazon_ads_mcp/actions/workflows/ci.yml)

**MCP registry id** (for clients and catalogs that display a stable package name): `io.github.KuudoAI/amazon_ads_mcp`

## Table of contents

- [What are MCP tools?](#what-are-mcp-tools)
- [What is Amazon Ads API MCP SDK?](#what-is-amazon-ads-api-mcp-sdk)
- [Quick start](#quick-start)
- [Installation](#installation)
- [Configuration](#configuration) (auth, packages, profiles, regions)
- [Downloading reports and exports](#downloading-reports-and-exports)
- [Example MCP client (Claude Desktop)](#example-mcp-client-connect-claude-desktop)
- [Context limits](#context-limits-and-active-mcp-server-tools)
- [Code mode](#code-mode)
- [Tool audit](#tool-audit)
- [Background tasks](#background-tasks)
- [Troubleshooting](#troubleshooting)
- [Documentation map](#documentation-map)

## 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](https://advertising.amazon.com/API/docs/en-us).

## 🚀 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](https://docs.docker.com/get-started/) (recommended), Python 3.10+ if you run from source, and [Amazon Ads API access](https://advertising.amazon.com/API/docs/en-us/guides/get-started/overview) (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](#configuration)).
3. `docker compose up -d`
4. Connect your MCP client to `http://localhost:/mcp/` — `.env.example` sets **`PORT=9080`** (override in `.env` if needed).

OAuth steps, client JSON samples, and a full variable reference: [Configuration](#configuration) below, [**INSTALL.md**](INSTALL.md), and [**AGENTS.md**](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)](https://advertising.amazon.com/API/docs/en-us/guides/campaign-management/overview), [Exports](https://advertising.amazon.com/API/docs/en-us/guides/exports/overview), [Amazon Marketing Cloud](https://advertising.amazon.com/API/docs/en-us/guides/amazon-marketing-cloud/overview), 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.

> **⚠️ Beta Notice**: These APIs are currently in beta at Amazon. Features and endpoints may change. Use in production with caution.

| Package Name | Description | Prefix |
|-------------|-------------|--------|
| `ads-api-v1-all` | Ads API v1 merged ALL surface | `allv1_` |
| `ads-api-v1-sp` | Sponsored Products v1 | `spv1_` |
| `ads-api-v1-sb` | Sponsored Brands v1 | `sbv1_` |
| `ads-api-v1-dsp` | Amazon DSP v1 | `dspv1_` |
| `ads-api-v1-sd` | Sponsored Display v1 | `sdv1_` |
| `ads-api-v1-st` | Sponsored Television v1 | `stv1_` |
| `ads-api-v1-beta` | Ads API v1 merged BETA surface | `beta_` |

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

```bash
# 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](https://advertising.amazon.com/API/docs/en-us/guides/campaign-management/overview).

## Installation

We recommend running Amazon Ads API MCP with 🐳 [Docker](https://docs.docker.com/get-started/). 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**](INSTALL.md). The README keeps the Docker quick path
short; `INSTALL.md` has the full install matrix and verification steps.

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

Copy the environment template:

```bash
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`):

```bash
docker compose up -d
```

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

Check logs:

```bash
docker compose logs -f
```

Stop the server:

```bash
docker compose down
```

For verification, upgrading, developer setup, and non-Docker installation
paths, see the [**Installation Guide**](INSTALL.md).

## 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](#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 two paths for connecting to the API;
1. Bring Your Own App (BYOA)
2. Leverage Partner Apps

## 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](https://developer.amazon.com/)
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:/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:
```bash
# 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`:

```bash
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:

```bash
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](#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.

### 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`
-

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [KuudoAI](https://github.com/KuudoAI)
- **Source:** [KuudoAI/amazon_ads_mcp](https://github.com/KuudoAI/amazon_ads_mcp)
- **License:** MIT
- **Homepage:** https://www.openbridge.com

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.2.6 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** yes
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.2.6** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-kuudoai-amazon-ads-mcp
- Seller: https://agentstack.voostack.com/s/kuudoai
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.