API integration Beta
API MCP
Give an AI client tools for an API you already use, starting from its OpenAPI description.
A read-only example
One API operation becomes one tool.
Suppose a service has an endpoint that lists the items belonging to an account. An AI client can use that operation through API MCP without needing a separate hand-written integration for it.
1. Select the operation
GET /widgets
operationId: listWidgets2. Call the exposed tool
list_widgets
query.ownerId: demo-owner3. Read the API response
200 OK
widgets:
- id: demo-01
name: Desk lampA fictional records service and sample response. The operation and parameter shape follow the repository’s example API contract. Nothing here connects to a live account.
See the example API contract ↗The description supplies the tool’s shape.
In the example contract, GET /widgets has operationId listWidgets. Its ownerId query parameter is required; page is an optional integer. API MCP exposes list_widgets with those inputs.
Keep the parameter in the right place.
The client supplies the account identifier in the query object. API MCP constructs the HTTP request to the configured destination and attaches credentials through the local configuration.
2. Call the exposed tool
list_widgets
{
"query": {
"ownerId": "demo-owner",
"page": 1
}
}The resulting request in this fictional service
GET https://api.example.com/v1/widgets
?ownerId=demo-owner&page=1demo-owner is example business data, not an API credential. A token belongs in the configured environment or supported credential store, rather than in this tool argument.
A successful response still needs interpretation.
The sample body shows one desk lamp. That demonstrates how data can come back to the client; it does not prove the account has only one item. Check the service’s filtering and pagination rules before presenting a complete inventory.
What happens at the boundary?
- Required input is missing
- Without ownerId, the call does not satisfy this operation’s declared input. Supply the missing value rather than inventing an account identifier.
- The next request would change data
- Listing items does not grant permission to create one. Tool policy determines which operations are available; on supported macOS builds, a non-read request also needs local native approval.
- The description is incomplete
- An OpenAPI document can describe the wrong fields or omit business rules. A schema-shaped call can still be inappropriate. I would check the actual API behavior with test data before relying on a new operation.
The reusable part is turning an explicit API contract into callable tools. Choosing the right account, a useful subset of operations and a reliable interpretation of the answer remains part of the integration.
From an API operation to a tool.
API MCP turns selected operations in an OpenAPI 3.x description into tools exposed through the Model Context Protocol (MCP). A tool call becomes a request to the underlying HTTP API.
It runs locally between an MCP-compatible AI client and the API. You choose the description, destination and credentials, along with the operations the client may call.
Start with a limited set of operations.
Managed configurations start read-only. You can enable named features or individual endpoints, with separate policies for different account profiles. Credentials come from environment variables or, on supported macOS builds, Keychain.
On macOS, policy changes and requests beyond reading require local native approval. You still need to inspect the API contract and test with non-production credentials before allowing writes: approval alone cannot tell you whether the description is accurate or a call is appropriate for your data.
API MCP is an independent public beta, unaffiliated with the API providers it connects. The repository covers platform support and setup. Billy MCP uses the same approach for accounting.
Ask me about API MCP →