# MCP Server

Source: https://env.7xmtools.com/api-docs/mcp.html

Put Keepa's Amazon data in the hands of AI assistants like Claude and ChatGPT through the hosted Model Context Protocol server. Nothing to install — sign in with your Keepa account or connect with your API key, and your assistant can research prices, deals, sellers and products on its own.

MCP · Streamable HTTP · Uses your plan's tokens

The [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) is an open standard that lets AI assistants call external tools. Keepa operates an official MCP server, **fully hosted**: there is nothing to download, install or update — clients connect to `https://env.7xmtools.com/mcp`, sign in with your Keepa account or send your Keepa API access key, and new server versions are live the moment they are deployed.

You need an active [Keepa API subscription](https://env.7xmtools.com/api/pricing) or Keepa Pro. Pro includes a small API allowance, enough to try the server; an API plan sets the rate for regular use. Your access key is shown on the [API page](https://env.7xmtools.com/api) of your Keepa account. Tool calls consume the same [tokens](https://env.7xmtools.com/api-docs/plans-tokens.html) as direct API requests.

## Connect your AI assistant

```
POST https://env.7xmtools.com/mcp
```

The endpoint speaks MCP over Streamable HTTP and accepts two kinds of authentication: a **sign-in with your Keepa account** (OAuth), which assistants with a connector screen such as Claude and ChatGPT use, and your **API access key** sent as a Bearer token, `Authorization: Bearer YOUR_API_KEY`, for clients set up through a configuration file or the command line.

### Sign in with your Keepa account

Add `https://env.7xmtools.com/mcp` as a custom connector and leave any client ID or secret fields empty. The assistant opens a keepa.com page that names the app and asks for your approval — log in there first if you are not logged in. After you approve, you return to the assistant and the connector is ready.

- **Claude** (claude.ai and the Claude apps): Settings ▸ Connectors ▸ Add custom connector, enter the URL, then Connect. On Team and Enterprise plans an owner adds the connector for the organization first.
- **ChatGPT**: custom connectors need developer mode, which you turn on under Settings ▸ Apps & Connectors ▸ Advanced settings. Then create a connector with the URL above and OAuth as authentication. Availability depends on your ChatGPT plan.
- **Claude Code**: `claude mcp add --transport http keepa https://env.7xmtools.com/mcp`, then run `/mcp` in a session, choose *keepa* and Authenticate.

What approving means:

- The app uses Keepa through your API access, so your account needs an active API subscription or Keepa Pro, and every tool call uses your tokens.
- The app never sees your password or your API key. Generating a new API key leaves connected apps working.
- You can disconnect an app at any time on the [API page](https://env.7xmtools.com/api) under *Connected apps*. Changing your password disconnects all of them.

### Quick setup by client

For clients set up with your API key — each tab shows the complete, verified setup. Replace `YOUR_API_KEY` with your Keepa API access key.

**Claude Code**

```bash
claude mcp add --transport http keepa https://env.7xmtools.com/mcp --header "Authorization: Bearer YOUR_API_KEY"
```

**Claude Desktop**

```json
// Claude ▸ Settings… ▸ Developer ▸ Edit Config — claude_desktop_config.json
// (bridges via the mcp-remote package; requires Node.js. Restart Claude Desktop afterwards.)
{
  "mcpServers": {
    "keepa": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://env.7xmtools.com/mcp",
               "--transport", "http-only",
               "--header", "Authorization:${AUTH_HEADER}"],
      "env": { "AUTH_HEADER": "Bearer YOUR_API_KEY" }
    }
  }
}
```

**Cursor**

```json
// ~/.cursor/mcp.json (global) or .cursor/mcp.json (per project)
{
  "mcpServers": {
    "keepa": {
      "url": "https://env.7xmtools.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}
```

**VS Code**

```json
// .vscode/mcp.json — VS Code asks for the key on first start and stores it encrypted
{
  "inputs": [
    { "type": "promptString", "id": "keepa-api-key", "description": "Keepa API key", "password": true }
  ],
  "servers": {
    "keepa": {
      "type": "http",
      "url": "https://env.7xmtools.com/mcp",
      "headers": { "Authorization": "Bearer ${input:keepa-api-key}" }
    }
  }
}
```

**Gemini CLI**

```bash
# -s user = save in ~/.gemini/settings.json (omit for per-project scope)
gemini mcp add -s user --transport http --header "Authorization: Bearer YOUR_API_KEY" keepa https://env.7xmtools.com/mcp
```

**Windsurf**

```json
// ~/.codeium/windsurf/mcp_config.json
{
  "mcpServers": {
    "keepa": {
      "serverUrl": "https://env.7xmtools.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}
```

**Codex CLI**

```bash
# Codex reads the key from the KEEPA_API_KEY environment variable —
# it is never written into the config file
codex mcp add keepa --url https://env.7xmtools.com/mcp --bearer-token-env-var KEEPA_API_KEY
```

**Cline**

```json
// Cline panel ▸ MCP Servers ▸ Configure. The type string must be exactly "streamableHttp"
// (Roo Code uses the same shape with "type": "streamable-http")
{
  "mcpServers": {
    "keepa": {
      "type": "streamableHttp",
      "url": "https://env.7xmtools.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}
```

**Other**

```json
// Any MCP client with Streamable HTTP + custom header support.
// Most read a JSON configuration in this common shape (file name and exact keys vary per client):
{
  "mcpServers": {
    "keepa": {
      "type": "http",
      "url": "https://env.7xmtools.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}
```

> **Tip:** Where possible, keep the key out of config files that might be committed or shared: VS Code prompts for it (`inputs`), Codex CLI reads it from an environment variable, and Cursor, Windsurf and Gemini CLI support `${env:…}`-style interpolation inside `headers`.

> **Note:** Claude Desktop can also skip the configuration file: its connector screen signs in with your Keepa account as described [above](https://env.7xmtools.com/api-docs/mcp.html#sign-in).

> **Important:** Your API key is a secret. Client configurations that embed it (for example a checked-in `.mcp.json`) must not be committed to shared repositories or otherwise published. Anyone with the key can spend your tokens.

## What your assistant can do

Once connected, the assistant can look up products with prices, statistics and Buy Box data, walk decoded price histories, render Keepa charts, search Amazon, run [Product Finder](https://env.7xmtools.com/api-docs/product-finder.html) and [Seller Finder](https://env.7xmtools.com/api-docs/seller-finder.html) database queries, browse recent price drops and Lightning Deals, pull category best sellers, inspect sellers and their storefronts, and manage price trackings with notifications. It can answer questions like *"How has the Buy Box price of this ASIN developed over the last year?"* or *"Find me kitchen products whose price dropped at least 30% this week"* by calling the Keepa API itself.

Every tool description states its token cost and every response carries your current balance, so a connected assistant paces its own spending — the balance it spends is your plan's. Responses are deliberately shaped for language models rather than for programs; if you are writing code against Keepa data, use the [REST API](https://env.7xmtools.com/api-docs/request-basics.html) directly.

## These docs for your assistant

If an assistant writes code against the API, or answers questions about it, point it at these Markdown versions of this documentation, made for reading by tools:

- [Quick reference](https://env.7xmtools.com/api-docs/quick-reference.md): every endpoint with its method, path, token cost and parameters, in one file.
- [llms.txt](https://env.7xmtools.com/api-docs/llms.txt): an index of every page, following the [llms.txt](https://llmstxt.org/) convention; [llms-full.txt](https://env.7xmtools.com/api-docs/llms-full.txt) holds all pages in one file.
- Each page as Markdown: the **Markdown** link at the top of every page opens it, and **Copy as Markdown** puts it on the clipboard to paste into a chat.