creatordb-mcp-server

A Model Context Protocol server that exposes the CreatorDB V3 API to any MCP-compatible client (Claude Code, Claude Desktop, Cursor, etc.).

48 tools across seven surfaces:

• Creator-side data — profile, performance, audience demographics, contact, content-detail, performance history for YouTube, Instagram, and TikTok

• Creator search — natural-language search across all three platforms, plus structured filter search per platform (country, language, follower thresholds, niches, hashtags, audience demographics, etc.)

• Brand-side / sponsor intelligence (YouTube + Instagram only — TikTok brand data is not indexed) — search CreatorDB's 10K+ indexed brands, pull a brand's full profile, list every creator a brand has sponsored, get aggregated audience demographics across a brand's sponsored creator pool, and cross-platform spend / CPM / CPE rollups. The heavier sponsor reads (get_sponsor_creators, get_sponsor_performance, get_sponsor_audience, get_sponsor_summary) cost 15 credits each — use deliberately. get_sponsor_information is 2, search_sponsors 2, list_sponsors 1.

• Content search — find individual posts (YouTube videos, shorts and streams; Instagram reels and posts; TikTok videos) by content-level filters (captions, hashtags, publish date, engagement thresholds, sponsorship) and creator-level filters, or within one creator's content. Different from creator search — this returns posts, not channels. Each call has a fixed price from a grid (time window, caption filter, follower floor, content type); with no window it searches the last 30 days.

• Topic + niche taxonomies — paged, searchable catalogs (~490 topics per platform, ~16K YT niches, ~40K each on IG/TT) for resolving the per-creator topic/niche IDs returned in profile responses. Pass search to resolve a phrase to entry IDs rather than paging; search filters take the id.

• Bulk vetting — vet_creators returns engagement, audience and sponsor details for up to 150 creators in one call.

• Account — credit usage broken down by endpoint and platform.

Every tool returns the underlying V3 JSON plus a Credits used: N | Remaining: M footer line, so the AI knows exactly what it's spending.

Working with Claude Code? Open this README in Claude Code (or paste the URL into a Claude session) and say "set up this MCP for me." The steps below are written so an AI assistant can follow them top to bottom.

Quick start

There are two ways to connect, depending on your client:

• Local clients (Claude Code, Claude Desktop, Cursor) run the server as a subprocess via npx — see Install (local / stdio).

• Web / desktop / mobile clients connect to the hosted endpoint, or add CreatorDB straight from Claude's connector directory — see Remote connector.

Both expose the same 48 tools. Both need a CreatorDB V3 API key.

1. Prerequisites

   • For the local route: Node.js 22 or newer (node -v to check)

   • A CreatorDB V3 API key — get one from https://creatordb.app account settings, or ask your team admin

2. Pick a connection method below

3. Restart your MCP client so it picks up the new tools

4. Verify by running /mcp in Claude Code — creatordb should appear with status connected

Related MCP server: Influship MCP

Install (local / stdio)

For Claude Code, Claude Desktop, and Cursor. The server reads one environment variable: CREATORDB_API_KEY (your V3 key).

Method A — npx from npm (recommended)

The package is published to npm as @creatordbai/mcp-server. No local clone, no SSH key, no GitHub access required:

Claude Code:

claude mcp add creatordb -s user \
  -e CREATORDB_API_KEY=YOUR_CREATORDB_API_KEY \
  -- npx -y @creatordbai/mcp-server

Claude Desktop — edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "creatordb": {
      "command": "npx",
      "args": ["-y", "@creatordbai/mcp-server"],
      "env": { "CREATORDB_API_KEY": "YOUR_CREATORDB_API_KEY" }
    }
  }
}

If you have GitHub org access and want to track main instead of the npm release, swap the npm name for git+ssh://git@github.com/CreatorDB/creatordb-mcp-server.git — the repo's prepare script will build on install.

Method B — clone and build locally

Good if you want to read/modify the source, or if npx from git doesn't work in your environment.

git clone https://github.com/CreatorDB/creatordb-mcp-server.git
cd creatordb-mcp-server
npm install
npm run build

# Then register with Claude Code:
claude mcp add creatordb -s user \
  -e CREATORDB_API_KEY=YOUR_CREATORDB_API_KEY \
  -- node "$(pwd)/dist/index.js"

For Claude Desktop, use the same JSON as Method A but swap command + args:

"command": "node",
"args": ["/absolute/path/to/creatordb-mcp-server/dist/index.js"],

Method C — project-scoped via .mcp.json (best for teams)

Drop a .mcp.json into a CreatorDB project repo. Anyone who opens that repo in Claude Code gets prompted to enable the MCP — no per-person setup commands.

{
  "mcpServers": {
    "creatordb": {
      "command": "npx",
      "args": ["-y", "git+ssh://git@github.com/CreatorDB/creatordb-mcp-server.git"],
      "env": { "CREATORDB_API_KEY": "${CREATORDB_API_KEY}" }
    }
  }
}

${CREATORDB_API_KEY} reads from the user's shell environment, so the key stays out of git. Each teammate sets it once in their .zshrc/.bash_profile:

export CREATORDB_API_KEY=YOUR_CREATORDB_API_KEY

Remote connector (Claude web, desktop, mobile)

Claude clients that can't spawn a local subprocess connect to the hosted endpoint instead of running npx. There are two ways in.

From the connector directory (easiest). CreatorDB is listed in Claude's connector directory. In Claude: Settings → Connectors → Add → Browse connectors, search CreatorDB, open CreatorDB MCP, and click Connect to Claude.

Add it manually. You can also add it directly: Settings → Connectors → Add → Add custom connector, and enter the URL:

https://mcp.creatordb.app/mcp

Leave the Advanced OAuth Client ID / Secret fields empty — the server registers the client automatically.

Either way, you'll be prompted to enter your CreatorDB API key when you connect, and the same 48 tools appear.

Notes:

• You'll be prompted to enter your key when you connect; the connector seals it into an encrypted session token and keeps no separate copy. CreatorDB stores the key only as the credential it issued you.

• Programmatic clients calling the endpoint directly can instead send Authorization: Bearer <your CreatorDB V3 API key>.

• Health check: https://mcp.creatordb.app/health (no auth, 0 credits) — returns {"status":"ok",...} when the service is up.

• Hosted as a Firebase Cloud Function (gen 2) in asia-northeast1; source is in functions/.

• Don't have a key? Get one at https://app.creatordb.app or email hello@creatordb.app.

Changing your API key

You don't update a key inside the MCP server — it doesn't store keys. You change it in your client's MCP configuration and restart.

Local install (Claude Code, Claude Desktop, Cursor)

Edit the same config file you used during setup:

• Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows)

• Cursor: ~/.cursor/mcp.json (or the in-app MCP settings UI)

• Claude Code: ~/.mcp.json or your project's .mcp.json

Change the CREATORDB_API_KEY value, then fully restart the client (⌘Q + reopen for Claude Desktop, restart the Cursor app, etc.). MCP clients only read the key at process startup.

If you set the key from your shell environment (Method C above, with ${CREATORDB_API_KEY} syntax), update ~/.zshrc / ~/.bash_profile and restart your terminal before restarting the client.

Remote connector (Claude web, desktop, mobile)

In Settings → Connectors → CreatorDB, disconnect and reconnect, then enter the new key when prompted. (A programmatic client sending a Bearer token just starts sending the new key.)

One thing to know about rotating a leaked key

Changing the key on the client side only swaps which key your tools authenticate with. It does NOT invalidate the previous key. If you're rotating because the old key was exposed:

1. Go to your CreatorDB account and revoke the old key there — that's what actually kills it at the V3 API layer.

2. Then update the MCP client to use the new key as above.

The MCP server never persists your key past a single request, so there's no server-side "stored key" to purge.

Verify it works

After install, restart Claude Code (or your MCP client) and:

1. Run /mcp — you should see creatordb listed with status connected

2. Ask Claude something that uses the tools, e.g. "use creatordb to look up the YouTube profile for MrBeast (channelId UCX6OQ3DkcsbYNE6H8uQQuVA)"

3. The response should include creator data and a Credits used: 2 | Remaining: … footer

Troubleshooting

Why restarts matter — MCP clients fetch the tool list once at session start. Server updates (new tools, renamed params, fixed costs) only show up after the client reconnects. This is the single most common confusion.

Upgrading to a newer published version? npx caches packages by exact version, so a configured client keeps running whatever version it first downloaded. To force-pull the latest, either pin to @latest in your config (npx -y @creatordbai/mcp-server@latest re-resolves each launch) or clear the npx cache once (rm -rf ~/.npm/_npx). Then restart the MCP client.

Releasing (maintainers)

The .github/workflows/release.yml workflow publishes to npm whenever a v*.*.* tag is pushed.

# bump version, commit, tag, push
npm version patch              # or minor / major
git push && git push --tags

The workflow validates that the tag matches package.json version, runs npm ci, builds, and publishes via npm Trusted Publishing with sigstore provenance attestation. No long-lived NPM_TOKEN is stored — the workflow exchanges a GitHub OIDC token for a short-lived npm publish token at runtime.

Roadmap

• Goal: list in the MCP registry and Claude's MCP marketplace so the server shows up when users browse MCP servers from inside their client.

• Contributions, issues, and feedback welcome — see Getting help below.

Tools

48 tools across six categories. Every tool returns a structured JSON payload plus a Credits used: N | Remaining: M footer line.

Account (1)

Search (5)

Filter type gotcha: numeric ops (>, <, = on subscriber/follower/rate fields) require a number value, not a numeric string. "1000000" → VALIDATION_ERROR; 1000000 → ok.

Niche and topic values: the niches and topics filters take taxonomy IDs (e.g. id_canva_Education). A display name (Canva) or the Name/Category form is converted to the matching IDs and the result says what it was converted to; the first conversion per taxonomy costs 1 credit and is then cached. A name with no exact match returns the closest IDs instead of running the search.

Enrichment (fields): add data from other endpoints to each result, billed per result at fractional prices, e.g. { "profile": ["bio", "niches", "country", "mainLanguage"], "content-detail": { "recentVideos": 3 } } = 0.7 credits per result. Useful for checking fit without a profile call per creator.

Empty results: a search with no matches returns a note on how to widen it.

Server instructions: the server sends instructions at connect time describing how the data works (exact filters, taxonomy IDs, country-level location) and the search method that returns the most relevant creators: gather candidates with several searches that use different topic signals and sort orders, enrich them with fields, then keep only creators whose own content shows they fit. A thorough search this way typically uses 50-150 credits. Agents state their plan before searching, share a preview of clear fits when early results allow, make independent calls together in the same turn, list only clear fits, stop once they have the number of creators the user asked for, and check shortlisted creators with one vet_creators call instead of per-creator lookups. When the user asks for speed they take a quick path: map niches for every platform in one turn, run two searches per platform together, keep the clear fits. Clients connected before an update see new instructions after reconnecting.

Result size: enriched search results are shortened in steps to stay within what MCP clients show to the model (long descriptions and bios first, then top-10 hashtag and niche lists, then recent posts reduced to their essentials). The result says what was shortened; get_*_profile and get_*_content_detail return full text. Tool results are compact JSON.

Filter value notes: hashtag values match with or without a leading # and are case-insensitive. Ratio and percentile fields (audienceMaleRatio, audienceFemaleRatio, and YouTube's *Percentile fields) take a decimal from 0 to 1, not 0-100: 0.6 = 60%, 0.9 = top 10%.

Sponsors / brand data (8)

Brand-side intelligence: which brands sponsor creators, how much they spend, which creators they work with. Sponsor data covers YouTube and Instagram only — TikTok is not indexed for brands.

Brand-key: brandId, typically the brand's primary domain (e.g. "acer.com", "nike.com").

Cost warning — get_sponsor_creators, get_sponsor_performance, get_sponsor_audience, get_sponsor_summary each cost 25 credits per call. Use search_sponsors / list_sponsors / get_sponsor_information for cheap exploration first.

YouTube creator data (7 + 5 platform-specific)

Creator-key: channelId (the UC… form — @handle / /c/ / /user/ URLs are not accepted; resolve first).

Instagram creator data (7 + 3)

Creator-key: uniqueId (the handle, no @).

TikTok creator data (7 + 2)

Creator-key: uniqueId (the handle, no @).

Cross-platform differences cheat-sheet

Niche IDs are not interchangeable across platforms — id_vlog_PeopleBlogs (YT) and id_love_All (IG) live in different namespaces. Niche/topic IDs follow the pattern id_{slug}_{Category}, so you can group by category by splitting on the last _.

Response shape highlights

These are the fields that aren't obvious from the endpoint name but you'll reach for constantly. All confirmed against live responses.

/profile

Shared across YT/IG/TT:

• subscriberGrowth: { g7, g30, g90 } — % change in subscribers/followers over the last 7/30/90 days. Free trend signal — no need to call performance-history if you only want the headline number.

• hashtags: [{ name, contentCount }] — hashtags the creator uses (note: name carries the # on IG/TT).

• niches: ["id_vlog_PeopleBlogs", …] — per-creator niche IDs. To resolve the human-readable name + category + channelCount, cross-reference list_{platform}_niches.

• relatedCreators — accounts the platform itself recommends or lists as related to the creator. YT: UC channelIds of channels YouTube recommends alongside this channel's videos, most frequent first. IG/TT: handles, passed through as the platform provides them. On TikTok the list often includes the creator's own handle. Cheap way to expand a seed list.

• hasEmail — whether get_{platform}_contact would return an email. Request it via fields (0.1 credit) before paying 15 for contact.

• isAgencyRepresented — true when CreatorDB has a record of agency representation; false also covers creators with no record.

• lastPublishTime / lastDbUpdateTime — Unix-ms; pair them to know how stale the snapshot is vs how recently the creator posted.

• country — ISO 3166-1 alpha-3 (e.g. "USA", "JPN"). On IG this value is derived from a content classifier rather than a self-declared field, and can occasionally be wrong for creators with multi-country presence — cross-check against audienceLocations and the creator's bio if accuracy matters.

YT-only:

• topics: ["id_challenges_Comedy", …] — coarse topic IDs (~490 per platform). Resolve via list_{youtube,instagram,tiktok}_topics.

• totalViews — lifetime channel views, as shown on the channel's About panel.

• joinedDate — when the channel was created (Unix ms, day precision).

• Sponsored video / shorts CPM and rate bands (videoPrice, shortsPrice) are no longer on profile; they're on get_youtube_performance.

• categoryBreakdown: [{ category, share }] — share of recent content by YouTube native category.

• hasMemberOnlyContents — boolean.

IG-only:

• isBusinessAccount, isPrivateAccount — flags worth checking before promising audience data; private accounts can't be scraped.

• otherLinks — bio links array.

• imageLastPublishTime / reelsLastPublishTime — latest image post and latest reel (Unix ms); lastPublishTime is the later of the two.

TT-only:

• otherLinks — bio link (TikTok allows one).

• joinedDate — when the account was created (Unix ms).

/audience

Identical shape across platforms:

• audienceLocations: [{ country, share }] — top 6 countries with shares summing to roughly 1.0.

• audienceGender: { maleRatio, femaleRatio } — sums to ~1.0; binary split only.

• audienceAvgAge — integer.

• audienceAgeBreakdown: [{ ageRange, share }] — fixed buckets 13-17 | 18-24 | 25-34 | 35-44 | 45-54 | 55-64 | 65+. Always 7 entries; placeholder rows are all-zero (see footgun list below).

/performance

The R20-vs-all distinction is YT-only:

• YT returns four sibling objects: videosPerformanceRecent, videosPerformanceAll, shortsPerformanceRecent, shortsPerformanceAll. "Recent" = R20 (last 20). "All" = up to 800. Each has likes/comments/views (with avg/median/min/max/percentile25/percentile75/iqr) and an engagement block.

• IG returns imagesPerformanceRecent + reelsPerformanceRecent. No all-time window.

• TT returns videosPerformanceRecent. No all-time window.

• Every engagement block ends with engagementConsistency: { cv, medianVsMean, topBottomRatio, consistencyScore, consistencyLevel }. consistencyScore is 0–100; consistencyLevel is "high" (81–100), "moderate" (51–80), or "low" (0–50). Requires ≥6 content pieces, otherwise the consistency block is absent.

• ranking block carries global, country, language percentile ranks for totalSubscribers/totalFollowers and avgEngagementRate — useful for "is this creator above average for their country" without separate benchmarking.

• recentVideosGrowth.g7/g30/g90 — engagement-rate delta over 7/30/90 days. Negative numbers mean engagement is declining.

• contentCountByDays: { 7d, 30d, 90d } — how many posts in each window (use to detect dormant creators).

/content-detail

Per-item objects across platforms:

• publishTime (Unix-ms), contentId, likes, comments, views (YT/TT only — IG images have no view count), engagementRate (rounded to 4 decimals).

• hashtags: ["#example", …] — already includes # prefix.

Platform-specific extras:

• YT: length (seconds), isMemberOnly, content mix includes both videos and shorts.

• IG: mentionedCreators — @-mentions in caption.

• TT: audioId, audioTitle, audioAuthor, audioAlbum, isDuetEnabled, isAd, length (seconds), shares. The audio block is the cheapest way to find trending sounds.

Freshness rule — content published within the last 4 days is excluded from all metric calculations (all platforms). Pinned-post rule — on IG/TT, a pinned post older than 90 days is excluded if it would be the oldest item in the sample.

/sponsorship

YT and IG only — TikTok does not have a per-brand sponsorship endpoint.

• sponsorList: [{ brandName, brandId, brandIgIds, sponsoredVideos, sponsoredVideosPerformance }].

• brandIgIds — the brand's IG handles. Use this to follow a brand from a sponsored creator back to the brand's own profile.

• sponsoredVideos includes each sponsored content's full per-item engagement (same shape as /content-detail).

• Important caveat — only scans the most recent ~20–30 posts and only detects brands already indexed in CreatorDB. An empty sponsorList is not proof the creator has no sponsors; it's "we didn't find indexed sponsors in their recent posts."

Search (search_{platform} and search_creators_nls)

Structured search response:

• creatorList: [{ displayName, uniqueId, channelId (YT only), avatarUrl, totalSubscribers | totalFollowers }] — minimal projection; hydrate with get_*_profile for full data.

• totalResults — total matching the filter set, not just the page.

• hasNextPage + nextOffset — pagination idiom. Pass nextOffset as the next request's offset to advance.

NLS response:

• Same creatorList shape as structured search, plus a platform: "youtube" | "instagram" | "tiktok" field telling you which platform the AI routed to.

• Streamed over SSE under the hood; the MCP layer collects the final data: event and returns it as one payload.

• Dynamic pricing — typically 1–10 credits depending on input + output token count.

/usage

• records: [{ date (YYYYMMDD), requestCount, totalQuotaUsed, endpoints: { …per-endpoint counts }, platforms: { …per-platform counts }, quotaByPlatform }].

• totalQuotaUsed can be fractional (e.g. 4.49 for an NLS call).

• endpoints keys are camelCase: getYoutubeProfile, getInstagramAudience, searchYoutube, getNLS, etc. Useful for building a spend dashboard.

Common footguns

• Placeholder demographics: when CreatorDB doesn't have real audience data, /audience returns the all-zero shape (audienceGender: { maleRatio: 0, femaleRatio: 0 }, age buckets all 0.0). Treat any row where male+female=0 as missing, not as "no gender data."

• Empty sponsorList ≠ no sponsors (see above).

• relatedCreators is unranked — order is not significance. Don't slice the first N and call them "top related"; sample or rerank by your own metric.

• Freshness lag — lastDbUpdateTime is when CreatorDB last refreshed. If it's older than ~14 days, the profile may not reflect recent breakout content.

• Niche channelCount drifts — list_*_niches is updated daily; don't cache it longer than that or your "creators in X niche" count will lag reality.

• Search the taxonomy, don't page it — list_*_niches returns one page at a time (100 by default, largest first) because the full taxonomies run to ~40,000 entries on Instagram and TikTok. Both are a single flat "All" category with no structure to browse, and the top 100 entries account for only ~18% of creator assignments, so paging rarely gets you anywhere. Pass search to resolve a phrase to niche IDs instead (the search filter takes each entry's id). Matching is whole-word, so skin will not find Skincare; CamelCase names are split (StreetFood matches street food) and common variants are folded (vloggers→vlog, japanese→japan). On TikTok ~44% of niches have under 100 creators — minChannelCount trims that tail.

• IG country is modelled, not self-declared — YouTube and TikTok return the country a creator set on their own profile; for Instagram, CreatorDB's location model supplies it, so IG has country coverage where the profile states nothing.

Filter reference (search tools)

Common fields across all three platforms:

• displayName — string, supports fuzzy

• uniqueId — string, exact

• country — string, ISO 3166-1 alpha-3 (e.g. "USA", "JPN", "GBR")

• mainLanguage — string, ISO 639-3 (e.g. "eng", "jpn", "zhs")

• hashtags — string (with # prefix on IG/TT)

• niches — string (use IDs from the platform's list_*_niches)

• mainAudienceLocation / mainAudienceAge / mainAudienceGender — string

• hasSponsors — boolean

Platform-specific:

• YouTube: totalSubscribers (number), topics (string from list_youtube_topics)

• Instagram / TikTok: totalFollowers (number)

Operators: >, <, = for numbers; =, in for strings; = for booleans. in takes an array of up to 100 values. pageSize max 100; filters max 10 per request.

Response envelope

Every tool returns the underlying CreatorDB V3 envelope:

{
  "data": { },
  "creditsUsed": 2,
  "creditsAvailable": 953270.5,
  "traceId": "abc-123",
  "timestamp": 1779722787120,
  "errorCode": "",
  "errorDescription": "",
  "success": true
}

On error, the envelope carries errorCode, error, message, and details. The MCP layer flattens that into a clean error message with a TraceId: line for support.

Development

npm run dev   # tsc --watch
npm run build # tsc once
npm start     # node dist/index.js

Source layout:

src/
  index.ts                 # registers all tools, stdio transport
  tools/
    account.ts             # 1 tool
    search.ts              # 4 tools (NLS + 3 platform creator searches)
    youtube.ts             # 13 tools (incl. search_youtube_content)
    instagram.ts           # 10 tools (incl. search_instagram_content)
    tiktok.ts              # 9 tools (incl. search_tiktok_content)
    sponsors.ts            # 8 tools (brand-side sponsor intelligence)
  util/
    api-client.ts          # fetch wrapper for REST + SSE
    response.ts            # MCP result formatter (credits, errors)

Getting help

• Bugs / feature requests / new endpoint coverage: open an issue at https://github.com/CreatorDB/creatordb-mcp-server/issues

• API key / data questions: hello@creatordb.app

• Just trying to install it on your machine? See SETUP.md — a 5-minute guide aimed at end users rather than contributors.

License

MIT