MCP server

Point Claude, ChatGPT, Cursor or any MCP-capable agent at the Tokfluence index and let it do the work: give it a brief, get back a ranked, saved creator list.

What it is

An MCP server hosted by us. Your agent connects to one URL with your existing API key and gets tools for searching creators, reading their posts, saving lists, and starting crawls for niches we don't cover yet.

The difference from calling the REST API yourself is where the judgement lives. You don't write the filter logic or the ranking; your agent reads the brief, decides what to search for, pages through the results, ranks the pool, and saves the list. You supervise it.

Connect it

One URL, and you sign in with your Tokfluence account. No key to copy, nothing to paste, and no Developer subscription: MCP access comes with Agency, Helios and Developer plans, and free accounts get API and MCP access with 50 credits a month.

https://developers.tokfluence.com/mcp

You choose what the assistant can do when you approve it. Searching and reading your lists always comes with the connection; starting crawls is a separate tick box, because each one costs credits, and you can leave it off. Everything you've connected shows up on the Connected apps page, where one click disconnects it.

Claude (web), Claude Desktop and Cowork

These three share one connector list, so you set it up once and it's available in all of them.

On a Pro or Max plan: open Customize → Connectors, click +, choose Add custom connector, paste the URL above, and click Add. Leave Advanced settings alone — the OAuth client ID and secret boxes are for servers that need pre-registered credentials, and ours registers Claude automatically.

On a Team or Enterprise plan: an Owner adds it once under Organization settings → Connectors. Everyone else then finds it under Customize → Connectors and clicks Connect to sign in with their own Tokfluence account. Each person's connection is their own: their credits, their lists.

Either way you'll land on a Tokfluence screen naming the app and listing what it will be able to do. Approve it and you're back in Claude with the tools live.

Claude Code

Add it once, then authenticate through the same browser sign-in:

claude mcp add --transport http tokfluence https://developers.tokfluence.com/mcp

Then run /mcp inside Claude Code and pick Tokfluence to sign in. If you'd rather skip the browser, an API key works too and is quicker for scripting:

claude mcp add --transport http tokfluence https://developers.tokfluence.com/mcp \
  --header "Authorization: Bearer $TOKFLUENCE_API_KEY"

Cursor, Windsurf, and other editors

Add this to your MCP config file (~/.cursor/mcp.json for Cursor):

{
  "mcpServers": {
    "tokfluence": {
      "url": "https://developers.tokfluence.com/mcp",
      "headers": {
        "Authorization": "Bearer tkf_live_your_key_here"
      }
    }
  }
}

Anything else

Any client that speaks Streamable HTTP works. The endpoint is POST https://developers.tokfluence.com/mcp, with either an OAuth token or an Authorization: Bearer tkf_live_... header.

Which one should you use?

For most work, use whichever you already live in. The tools and the index are identical everywhere; what differs is how much grinding the surface will do in one go.

Claude web, Desktop or Cowork is the right choice for briefs and client work, and for anyone who isn't a developer. Describe what you're after, answer the questions it asks, get a list.

Claude Code is better when you want hundreds of creators. It sustains long runs of tool calls without the conversation getting unwieldy, and it can farm the reviewing out across several passes. Our own largest hand-built lists were made this way.

Cursor, Windsurf and other editors work fine. They authenticate with an API key rather than sign-in, so the connection isn't scoped: it can do everything, including start crawls.

Tools

Fifteen tools, in the order you'd normally use them.

Seed campaigns, and how the assistant asks first

Everything else reads the index. create_seed_campaign changes it: you give it hashtags, our crawler walks them, discovers creators, and adds the ones it scrapes with 1,000 followers or more to the shared index, where every search can find them.

It runs for hours, not seconds, and results arrive gradually. The shape of the work is: start the campaign, keep building the list from what's already indexed, and check back later.

Seed it from suggest_campaign_keywords rather than from guesses. Asked for bladder health, most people write #pelvicfloor, #womenshealth, #bladderhealth. The index says those creators post under #kegels, #prolapse, #incontinence and #urinaryincontinence, and that #womenshealth sits on so many profiles it steers nothing. More good seeds is better, not worse: each is a starting point the crawler expands from, and a crawl only compounds when its seeds turn up high-signal neighbouring tags to follow.

Because it spends real money, it takes two calls. The first returns what would be crawled, the cost, and your current balance, and starts nothing. Your assistant is instructed to put that in front of you and wait:

The index is thin on Bulgarian live shopping, so I can crawl TikTok for
#livebg and #liveshopping to find creators we don't have yet.

That costs 250 credits, leaving you 750, and runs for a few hours with
results arriving gradually. In the meantime I'll keep building the list
from what's already indexed.

Want me to start it?

Only after you say yes does it call again to actually start the crawl. It's a two-step contract rather than a protocol prompt, so it works the same in every client.

The recipe prompt

The server ships an MCP prompt called build_creator_list. It takes a brief and walks your agent through the method we use ourselves: read the brief for what makes a creator a yes or a no, sweep with several searches rather than one, rank on evidence instead of follower count, spend the live post fetch only on the candidates the decision turns on, ask before crawling, then save the list best-match-first.

You don't strictly need it. The same loop is in the server's instructions, which every client reads on connect, so an assistant handed a brief will follow it anyway. The prompt is the version you invoke deliberately when you want the full treatment.

In Claude Code it appears as a slash command. In other clients, look for the prompt or "template" picker. It is worth using: the difference between an agent with tools and an agent with tools and a method is most of the quality.

Credits

MCP calls bill the same wallet as the REST API, at the same per-endpoint rates, and appear in your usage reporting under the tool that ran. The refund rule is the same too: a tool call that fails is refunded in full. search_creators is priced as REST search. A search call costs 1 credit, plus 1 per profile with contact details it returns. When your balance cannot cover every profile with contact details, the page still comes back whole, the ones it could not pay for without their contact values, and the result's billing object says how many. The agent controls the cost with has_email: true for creators it can reach, false (with has_phone: false) for a pool without contact details at 1 credit a page.

Free: 50 credits a month, shared by the app, the API and MCP, no rollover. Agency, Helios and the Developer plans include a larger monthly grant; if you hold more than one, you get the larger. Check your balance on the Credits page.

Two costs dominate: get_creator_posts at 25 credits per creator, and create_seed_campaign at 250. Both are stated in the tool descriptions your agent reads, so a well-behaved agent rations them, but they are the two to watch.

OAuth details

For anyone implementing a client, or reviewing this before approving it in an organisation.

• OAuth 2.1 authorization code with PKCE. S256 only; PKCE is required, not optional.
• Discovery is RFC 9728 protected-resource metadata at /.well-known/oauth-protected-resource/mcp, pointing at authorization-server metadata (RFC 8414) at /.well-known/oauth-authorization-server.
• Client registration works two ways: a Client ID Metadata Document (an HTTPS URL you host, which becomes your client_id), or Dynamic Client Registration at /oauth/register. The metadata document is preferred and is what the current MCP spec recommends.
• Redirect URIs must be https, or http on a loopback address for desktop and CLI clients. Matching is exact, with no wildcards.
• Access tokens last an hour and refresh silently. Revoking a connection kills its tokens immediately rather than at the end of the hour.
• Authorization responses carry iss (RFC 9207), and tokens are audience-bound to this MCP server (RFC 8707).

Transport details

For anyone implementing a client by hand:

• Streamable HTTP, JSON-RPC 2.0, one message per POST, one JSON response back.
• Stateless. No Mcp-Session-Id is issued or required, and every request is self-contained.
• No SSE. GET and DELETE return 405.
• A notification (a message with no id) gets 202 with an empty body.
• Auth failures return the JSON-RPC error envelope with a WWW-Authenticate header, not the REST API's error shape.
• X-Credits-Remaining is set on any response whose tool call was billed.

curl https://developers.tokfluence.com/mcp \
  -H "Authorization: Bearer $TOKFLUENCE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "search_creators",
      "arguments": { "query": "pelvic floor", "min_followers": 10000 }
    }
  }'