Skip to content
flint

Model Context Protocol

Two MCP servers. One reads the docs. One does the work.

Point any MCP client at the hosted docs server for live search and exact endpoint schemas, no API key required. Run flint mcp serve when the agent should create real resources with your credential, behind gates it cannot talk its way around.

Get free API keys
Read the MCP server guide
Connect in one line
claude mcp add --transport http flint-docs \
  https://developers.withflintpay.com/mcp

The docs server is public and read-only. It covers documentation only, so there is no account access to configure and nothing to revoke.

4 docs tools, no auth · 186 account tools via the CLI · one credential, held locally

01The read server

Live docs, exact schemas.

An agent that guesses field names from memory ships bugs. These four tools let it work from the current API surface instead.

Claude Code
claude mcp add --transport http flint-docs \
  https://developers.withflintpay.com/mcp

Search guides, the API reference, and the blog. Returns matching pages with URLs.

search_docs

Fetch one docs page as Markdown by its path.

get_page

List public API endpoints with method, path, and summary, optionally filtered by resource.

list_endpoints

Full reference for one endpoint: request and response schemas plus code samples.

get_endpoint

A typical loop is search_docs or list_endpoints to find the right operation, then get_endpoint for its exact request and response schemas before writing the call. The same corpus is also one file at llms-full.txt if you would rather load it up front.

02The write server

Real resources, your credential.

flint mcp serve exposes the CLI's canonical commands as MCP tools over stdio. The agent gets the same surface you get on the terminal, with the same names.

Start it
# import a key once, into the OS keychain
flint auth import --stdin < key.txt

# every canonical command becomes a tool
flint mcp serve

# or register it with Claude Code
claude mcp add flint -- flint mcp serve

The credential is resolved the normal CLI way, from the OS keychain or FLINT_API_KEY. The key prefix decides the environment: a sandbox key can only ever act on your sandbox.

One tool call
{
  "jsonrpc": "2.0", "id": 7,
  "method": "tools/call",
  "params": {
    "name": "payment-intents.create",
    "arguments": {
      "amount": 1999,
      "currency": "USD",
      "_flint": { "idempotency_key": "agent-run-42" }
    }
  }
}

Tool names are canonical command names, and arguments are the command's own argument names, generated from the same schemas that back the CLI's help and validation. Nothing on this page is a second, marketing-only surface.

Some of the tools

  • payment-intents.create
  • payment-intents.confirm
  • orders.create
  • orders.pay
  • refunds.create
  • checkout-sessions.create
  • customers.create
  • webhook-events.list
  • request-logs.list
  • sandboxes.test-key
  • timeline
  • listen

186 tools today, generated from the CLI's command catalog. New commands become tools when they ship.

03Guardrails

Deny by default, override by name.

An MCP server that can move money has to assume the model calling it will eventually do something wrong. This one is built so the wrong thing returns an error instead of a payment.

The _flint control object, in every tool's input schema
"_flint": {
  "live":            { "type": "boolean" },
  "confirm":         { "type": "boolean" },
  "idempotency_key": { "type": "string" },
  "dry_run":         { "type": "string", "enum": ["client"] },
  "max_events":      { "type": "integer" },
  "for":             { "type": "string" }
}

Overrides are per call and explicit. Which keys a tool advertises depends on what it is: idempotency keys and dry runs on mutations, confirmation on sensitive or destructive commands, bounds on streams.

Your secret key cannot pass through the agent. Key import is deliberately not a tool; the credential lives in the keychain or the environment.

flint auth import

A live credential does nothing until the agent acknowledges live mode on that specific call.

LIVE_ACKNOWLEDGEMENT_REQUIRED

Destructive commands, and sensitive writes in live mode, fail closed until explicitly confirmed. The server never prompts and never assumes.

CONFIRMATION_REQUIRED

Every tool declares whether it reads, mutates, or destroys, so a client can gate on it.

readOnlyHint · destructiveHint

Streaming tools require a bound, and Flint caps them at 100 records or two minutes regardless.

_flint.max_events · _flint.for

04Beyond MCP

The rest of the agent surface.

MCP is one way in. The same docs and schemas are published in the formats agents already read.

SKILL.md: the whole public API as one dense file, sized for a context window. Paste it into CLAUDE.md, AGENTS.md, or a system prompt.

developers.withflintpay.com/SKILL.md

Every docs page serves raw Markdown when you append .md to its URL, and the full corpus ships as llms.txt and llms-full.txt.

/llms.txt · /llms-full.txt

The OpenAPI spec is public, no key required, so codegen and validators can work from the same contract the docs do.

api.withflintpay.com/v1/openapi.json

Agents that drive the CLI directly can pull machine-readable schemas for every command, error, and event instead of scraping help text.

flint schema commands --output json

The LLM integration guide covers when to reach for which: one file up front, or live lookups over MCP.

05Start

Give an agent the keys. The test ones.

Connect the docs server

https://developers.withflintpay.com/mcp

Install the CLI

npm install -g @flintpay/cli

Import a sandbox key, start flint mcp serve, and ask your agent to create an order, pay it with a test card, and read the timeline of what just happened. The whole loop runs without a browser.

Then read these

  1. 01MCP server guide
  2. 02Flint CLI
  3. 03LLM integration
  4. 04Full API reference
Get free API keys

FAQ

Questions worth asking first.

Does Flint have an MCP server?

Two. The docs server at developers.withflintpay.com/mcp is hosted, public, and read-only: any MCP client can search the docs and pull exact endpoint schemas without an API key. The account server is flint mcp serve, part of the Flint CLI: it runs locally over stdio and exposes every canonical CLI command as a tool, so an agent can create and inspect real resources with your credential. Use them together, one to read and one to act.

Do I need a Flint API key?

Not for the docs server, which covers documentation only and never touches an account. The account server needs a credential the normal CLI way: import a key once with flint auth import, which stores it in the OS keychain, or set FLINT_API_KEY. The key's prefix decides the environment, so a flint_test_ key can only ever act on your sandbox.

Which MCP clients work?

Any client that speaks the protocol. Claude Code and Cursor configs are on this page; the docs server is stateless JSON-RPC 2.0 over HTTP POST, so even curl works. The account server is a standard stdio server, the shape every MCP client supports for local tools.

Can an agent move real money?

Only deliberately, twice over. With a live credential, every call fails with LIVE_ACKNOWLEDGEMENT_REQUIRED until the agent explicitly passes the live control on that call. Destructive commands, and sensitive writes in live mode, additionally fail with a confirmation error until explicitly confirmed. The server never prompts and never assumes: a call that would need a human answering yes returns a structured error instead of proceeding.

Why is the account server local instead of hosted?

Credential custody. Your secret key stays in your keychain or your environment, on your machine. It never appears in agent arguments, because key import is deliberately not an MCP tool, and it never transits anyone else's server. The hosted docs server is the mirror image: it can be public precisely because it holds no credentials and touches no accounts.