Skip to main content
The Model Context Protocol (MCP) lets agents like Claude, Cursor, and VS Code call tools through a standard interface. CreatorAudit runs an official, hosted MCP server at https://mcp.creatoraudit.com/mcp that exposes the full v2 API as agent tools ā€” list and track accounts and videos, group creators, and read analytics. Thereā€™s nothing to install: connect your client to the URL with your API key.

ā€‹
Set up in 3 steps

1

Get your API key

In your CreatorAudit dashboard, open the API keys page from the sidebar, click Generate key, and copy it (itā€™s shown only once). See Manage API keys for the full flow.Keys are organization-scoped, so every call the agent makes is confined to your workspace. Reads work with any valid key; tracking, creating, and deleting need a write-scoped key.
2

Add the server to your client

Use an HTTP transport. Header-capable clients send the key in a header; clients that take only a URL (Claude Desktop, ChatGPT) put it in the URL. Restart the client fully after editing a config file.
claude mcp add --transport http creatoraudit https://mcp.creatoraudit.com/mcp \
  --header "Authorization: Bearer YOUR_API_KEY"
A URL key can be captured by server access logs, so prefer a header where your client supports one. If a client reserves Authorization for its own auth, send the key as an x-creatoraudit-api-key header instead.
3

Verify the connection

Ask the agent to run get_api_key_info (or ā€œwhich organization is my CreatorAudit key for?ā€). It should return your organization ā€” youā€™re connected. Tool discovery works without a key; every data call needs a valid one, which the v2 API validates.

ā€‹
Tool surface

Full v2 parity ā€” every v2 endpoint is a callable tool, plus a call_v2_endpoint escape hatch and meta tools. To stay token-efficient, only a small pinned core appears in the standing tool list; the rest are found via search_tools or the built-in get_help catalog and stay directly callable by name.
GroupTools
Accountslist_accounts, get_account_details, track_account āš ļø, update_account, stop_tracking_account āš ļø, get_account_stats
Videoslist_videos, get_video_details, track_video āš ļø, update_video, stop_tracking_video āš ļø, list_account_videos, list_account_discovered_videos, get_account_discovered_video
Creatorslist_creators, get_creator_details, create_creator āš ļø, update_creator, delete_creator āš ļø, link_account_to_creator āš ļø, unlink_account_from_creator āš ļø
Analyticsget_org_timeseries, get_account_analytics, get_account_timeseries, get_creator_analytics, get_creator_timeseries, get_video_analytics, get_video_timeseries, get_video_deltas
Batchget_accounts_windowed_metrics, get_videos_windowed_metrics, get_account_videos_windowed_metrics, get_video_deltas_batch
Discoverysearch, get_top_creators, get_org_overview
Systemget_api_key_info (whoami), check_api_health, get_api_meta, call_v2_endpoint
Metaget_help(topic?), search_docs(query), search_tools, call_tool
āš ļø marks destructive writes ā€” your client is prompted to confirm before they run. track_account returns before metrics land; the first scrape is asynchronous, so check back later. Call get_help for the full catalog plus convention notes (auth, pagination, idempotency, errors, scopes, and the track ā†’ wait ā†’ read workflow), and search_docs to query this site live.
Anything not yet wrapped as a named tool is reachable through the escape hatch: call_v2_endpoint(method, path, params, body), where path is relative to the v2 root (e.g. /accounts). The same auth, idempotency, and RFC 9457 error surfacing apply.

ā€‹
How auth works

You bring your own key; the server holds none of its own. It reads your key from the request ā€” Authorization: Bearer or x-creatoraudit-api-key header, or an ?api_key= URL query parameter (a header takes precedence) ā€” and uses it only for your calls. Concurrent callers are isolated, so one connection never sees anotherā€™s data. The key stays in your client config, never in tool arguments or responses, and writes auto-attach an Idempotency-Key so retries are deduped. Because keys are organization-scoped server-side, an agent canā€™t reach another orgā€™s data even if it tries. See API setup for the shared API conventions.

ā€‹
Search these docs over MCP

This documentation site also hosts an MCP server at its /mcp path, with search and content-retrieval tools so your agent can look things up live. 
claude mcp add --transport http creatoraudit-docs https://docs.creatoraudit.com/mcp
Each page also offers Copy page, View as markdown, and Add to Cursor / VS Code / Claude in its context menu ā€” handy for dropping a single page into your agent.

ā€‹
Build a custom server

For most teams the official server is what you want ā€” it covers the whole v2 API and is maintained alongside it. Build your own only to expose a narrow subset of endpoints, add organization-specific logic (extra validation, redaction, defaults), or run on a different runtime. The example below wraps three endpoints ā€” search, overview, and list_accounts ā€” and passes responses through unchanged. Read the key from an environment variable; never bake it into the tools or return it in a response.
1

Set your key as an environment variable

export CREATORAUDIT_API_KEY="YOUR_API_KEY"
2

Implement the server

import os
import httpx
from mcp.server.fastmcp import FastMCP

BASE = "https://api.creatoraudit.com/v2"
HEADERS = {"Authorization": f"Bearer {os.environ['CREATORAUDIT_API_KEY']}"}
mcp = FastMCP("creatoraudit")


async def _get(path: str, params: dict | None = None) -> dict:
    async with httpx.AsyncClient(base_url=BASE, headers=HEADERS) as client:
        resp = await client.get(path, params=params or {})
        # On 4xx/5xx the body is RFC 9457 problem+json; surface it as-is.
        return {
            "status": resp.status_code,
            "request_id": resp.headers.get("X-Request-ID"),
            "body": resp.json(),
        }


@mcp.tool()
async def search(q: str, limit: int = 20) -> dict:
    """Search tracked accounts, creators, and videos."""
    return await _get("/search", {"q": q, "limit": limit})


@mcp.tool()
async def overview(period: str | None = None) -> dict:
    """Organization-level headline figures."""
    return await _get("/overview", {"period": period} if period else None)


@mcp.tool()
async def list_accounts(limit: int = 50, cursor: str | None = None) -> dict:
    """List tracked accounts (one page). Pass the returned next_cursor to page."""
    params = {"limit": limit}
    if cursor:
        params["cursor"] = cursor
    return await _get("/accounts", params)


if __name__ == "__main__":
    mcp.run()  # stdio transport
3

Register it with your agent

Point your client at the local server (Claude Code, Python example):
claude mcp add creatoraudit-custom -- python server.py
Keep the key server-side, read from an environment variable. Never bake YOUR_API_KEY into a tool definition or return it in a tool response. Mint an Idempotency-Key on every write, and flag destructive tools so the client can prompt before mutating data ā€” the official server does both for you.