MCP link
TRANXACT published data
The data an administrator has published, as MCP tools for an AI assistant: list, read, create, change and delete exactly what the key was granted, as a named user, on the audit trail.
https://<your-deployment>/api/v1/mcpMake your link
Stays in this browser. What you type here is used only to fill in the snippets on this page. The page makes no network request with it, does not store it (not in cookies, not in local storage), and has no form to submit, so it never reaches help.tranxact.ai or anybody else. Close or reload the tab and it is gone. Copying a snippet puts your API key on your clipboard; paste it where it belongs and nowhere else.
What it is
A Model Context Protocol server over the data your company has published in API Studio. An AI assistant connected to it (Claude Code, Claude Desktop, Cursor, VS Code, or your own agent) is offered one tool per thing its API key may do — and nothing else. There is no tool for data nobody published and no tool for a verb nobody granted, and every call is made as a named user of your company, through the same route the screen uses, onto the audit trail.
It is the same publication that serves the REST API at /api/v1, described for a model rather than for a developer. The background, and how it fits with the REST API, is in the guide TRANXACT as an MCP server.
| Endpoint | POST https://<your-deployment>/api/v1/mcp |
|---|---|
| Transport | MCP streamable HTTP, request and response only: POST one JSON-RPC message, get one JSON answer. There is no event stream and no session id; a GET answers 405 (after the key is checked). |
| Protocol version | 2025-06-18; a client asking for 2025-03-26 or 2024-11-05 gets that version back. |
| Methods | initialize, ping, tools/list, tools/call, and notifications (answered 202 with no body). Anything else is JSON-RPC error -32601, by name. |
| Authentication | Authorization: Bearer <key>, or X-API-Key: <key> for software that can only send a fixed header name. No OAuth. |
| Credential | An API key issued to an API client whose Protocol is MCP or both. |
| Multi-tenant deployments | On access.tranxact.ai, cpa.tranxact.ai and ca.tranxact.ai, also send X-TMULTI-Tenant: <account>, or use the account’s own address https://<account>.access.tranxact.ai/api/v1/mcp. The key itself does not choose the account there. |
| Server name | TRANXACT — <your company>; its instructions are the client’s What to tell an MCP client, or a default saying these tools reach live records. |
Get the API key
An administrator issues the key. The screens are named as the console names them: module › group › section › screen, as the Platform home page and the side menu show them. Whoever does this needs a role that may change API Clients.
- Publish what the assistant may use. Open Platform › Connectivity › Published API › Exposures and add one: Published as (the code that becomes the tool name), the Module and Screen, which verbs May be read / created / changed / deleted, the Columns and Rows that may travel, and Most rows per call (200 unless you change it, at most 5,000). Tick Offer as an MCP tool — without it the exposure serves REST only and no tool appears — write What to tell a model if the description is not enough, and set Status to active.
- Register the assistant. On Platform › Connectivity › Published API › API Clients, add a client: a name, What software is this, Who to ask about it. Set Protocol to mcp or both — a new client is rest, and a REST key at this endpoint is refused. Set Acts as to a user made for the purpose with the narrowest role that works: every call is made as that person. Optionally write What to tell an MCP client, set an Expires date, and change Rate limit per minute (120 for a new client).
- Grant it the exposures. On Platform › Connectivity › Published API › API Grants, add one row per exposure: the client, the exposure, and May read / create / change / delete. What the key may do is this grant AND the exposure, never more than either.
- Say where it will be used from. Only from allowed addresses is on for a new client, and a client with no addresses reaches nothing. On Platform › Connectivity › Published API › Allowed Software, add the public address the MCP client calls from: for Claude Code, Claude Desktop, Cursor or VS Code that is the computer’s (or the office network’s) public IP, as an ip or a cidr entry. Switch the requirement off only as a deliberate decision that the key may be used from anywhere.
- Issue the key. Back on API Clients, select the client and choose Issue key. The key (
tx_<client>_…) is shown once. Copy it straight into the panel above or into your client’s configuration. Issuing again replaces it and stops the old one at once. - Check it. Platform › Connectivity › Published API › API Studio shows each key’s readiness and what it could not do; API Call Log lists every call, allowed or refused, with the reason.
Connect a client
Every snippet below is filled in by Make your link; each has a Copy button. On a multi-tenant deployment the account header is added for you.
Claude Code (terminal or VS Code)
claude mcp add --transport http tranxact https://<your-deployment>/api/v1/mcp \
--header "Authorization: Bearer <your-API-key>"Add --scope project to write it into the folder’s .mcp.json for everyone who opens it (keep that file out of version control while it holds a API key), or --scope user for every folder. claude mcp list shows whether it connected; /mcp inside Claude Code shows its tools. The same thing as a .mcp.json file:
{
"mcpServers": {
"tranxact": {
"type": "http",
"url": "https://<your-deployment>/api/v1/mcp",
"headers": {
"Authorization": "Bearer <your-API-key>"
}
}
}
}Claude Desktop
{
"mcpServers": {
"tranxact": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://<your-deployment>/api/v1/mcp",
"--header",
"Authorization:${TRANXACT_AUTH}"
],
"env": {
"TRANXACT_AUTH": "Bearer <your-API-key>"
}
}
}
}Claude Desktop: Settings › Developer › Edit Config opens claude_desktop_config.json (Windows %APPDATA%\Claude, macOS ~/Library/Application Support/Claude). Merge this in and restart Claude Desktop. It runs mcp-remote (Node.js 18 or later), which carries the header to TRANXACT. The header value lives in env rather than in args because a space inside an argument is mangled on Windows.
Custom connectors added in claude.ai (Settings › Connectors › Add custom connector) ask for a URL and, optionally, OAuth client credentials; they have no place for a fixed Authorization header. TRANXACT’s MCP endpoints take a API key in a header and do not offer OAuth, so connect through Claude Desktop’s configuration file above, Claude Code, or another client that sends headers.
Cursor
{
"mcpServers": {
"tranxact": {
"url": "https://<your-deployment>/api/v1/mcp",
"headers": {
"Authorization": "Bearer <your-API-key>"
}
}
}
}Then Cursor Settings › MCP shows the server and its tools.
VS Code
{
"servers": {
"tranxact": {
"type": "http",
"url": "https://<your-deployment>/api/v1/mcp",
"headers": {
"Authorization": "Bearer <your-API-key>"
}
}
}
}Better, VS Code can ask for the API key when it starts the server and keep it out of the file:
{
"inputs": [
{
"type": "promptString",
"id": "tranxact-credential",
"description": "TRANXACT API key",
"password": true
}
],
"servers": {
"tranxact": {
"type": "http",
"url": "https://<your-deployment>/api/v1/mcp",
"headers": {
"Authorization": "Bearer ${input:tranxact-credential}"
}
}
}
}Start it from the file (the Start button above the server) or with MCP: List Servers; use it from Copilot Chat in agent mode.
Test it with curl
For bash or zsh (on Windows, Git Bash or WSL). Each answers one JSON-RPC message.
curl -s https://<your-deployment>/api/v1/mcp \
-H "Authorization: Bearer <your-API-key>" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1.0"}}}'curl -s https://<your-deployment>/api/v1/mcp \
-H "Authorization: Bearer <your-API-key>" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'curl -s https://<your-deployment>/api/v1/mcp \
-H "Authorization: Bearer <your-API-key>" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"list_<code>","arguments":{"limit":5}}}'Tools
tools/list answers the tools this key may call, built from its grants; two keys to the same company can see entirely different lists. Each tool name is a verb and the exposure’s Published as code in lower case, any other character an underscore (Sales-Orders becomes sales_orders).
| Tool | Offered when | Arguments | What it does |
|---|---|---|---|
list_<code> | the grant and the exposure allow read | q (free-text search), limit (50 by default, up to the exposure’s Most rows per call), offset, sort (column:asc or column:desc) | Records through the exposure’s row filter and columns. Answers { rows, count, limit, offset }. Marked read-only and idempotent. |
get_<code> | read | id (required) | One record, read through the same row filter, so an id outside it is “not published here”. Read-only. |
create_<code> | create | record (required): the fields; with listed columns, only those | Creates a record with the screen’s own validation, numbering, posting rules and audit trail. Fields the exposure does not carry are dropped. |
update_<code> | change | id, record (both required) | Changes a record it can read through the exposure. Refused where the product refuses anybody: a posted document, a closed period, a system number. |
delete_<code> | delete | id (required) | Deletes a record it can read through the exposure, permanently. Marked destructive, so a client asks before calling it. |
Every result carries a text block (the JSON, for any client) and structuredContent (the same data, for a client that reads it). A refusal comes back as a tool result with isError: true and a sentence the model can act on — “This key may not delete Purchase Orders. It is published and granted for read.” — rather than as an HTTP error.
Limits and reach
| Limit | How it works |
|---|---|
| Rate | Each key: its client’s Rate limit per minute (120 for a new client; 0 means no limit), counted across every server of the deployment over the last minute. Over it: HTTP 429 with Retry-After: 60. Answers carry X-RateLimit-Limit. |
| Calls without a valid key | An address that has had 20 calls refused for want of a valid key in 10 minutes is answered 429 (with Retry-After) before any key it sends is looked at, until those age out. An address on Allowed Software as an exact ip is never held off this way. |
| Rows | limit defaults to 50 and is capped by the exposure’s Most rows per call (200 by default, 1 to 5,000). Page with offset. |
| Columns and rows | Only the exposure’s columns ever travel, in or out; its Rows that may travel filter is applied on every call and nothing the caller sends widens it. |
| Verbs | The grant’s May read / create / change / delete AND the exposure’s. A grant may carry an expiry date. |
| Identity | Every call runs as the client’s Acts as user, who must be active and in the same company. Whatever that person may not do, the key may not do. |
| Where from | With Only from allowed addresses on (the default), the call must come from an origin, host, IP or IPv4 network on Allowed Software. |
| Key lifetime | Until the client’s Expires date, until it is replaced by Issue key, or until it is withdrawn (Withdraw key) or the client is suspended or revoked. |
What the key can reach, and what it cannot
- Can: exactly the active exposures granted to it, marked Offer as an MCP tool, with the verbs both allow, through each exposure’s columns and row filter, as its Acts as user.
- Cannot: any screen nobody published; a column the exposure leaves out; a row outside its filter, even by id; a verb nobody granted; anything its Acts as user could not do on screen; another company; the console itself (the key opens
/api/v1only); the REST API if the client’s protocol is mcp (the OpenAPI document excepted).
Errors people commonly hit
| Answer | What it means | What to do |
|---|---|---|
| 401 No API key. Send it as "Authorization: Bearer <key>", or as X-API-Key. | No credential arrived. The header is missing, misspelt, or your client dropped it. | Check the header in your client’s configuration; for Claude Desktop, the env entry. |
| 401 That API key is not recognised. | The key is wrong, was replaced by a newer Issue key, or was withdrawn. (A revoked key gets the same sentence, deliberately.) | Ask the administrator to issue a new key. |
| 403 This API key has been suspended / revoked., This API key has expired. | The client’s status or its Expires date. | An administrator changes the client on API Clients. |
| 403 This key is issued for the REST API. Issue an MCP key, or set this client’s protocol to MCP or both. | The client’s Protocol is rest — the default for a new client. | Set Protocol to mcp or both on API Clients. The key does not change. |
| 403 This API key has no allowed addresses… / …is not allowed to be used from here (address …) | Only from allowed addresses is on, and this computer’s address is not on Allowed Software. The sentence names the address the server saw. | Add that address (ip) or your network (cidr) on Allowed Software. |
| 429 This key is limited to N calls a minute… | The client’s rate limit. | Wait for Retry-After; ask for a higher limit if the work needs it. |
| 429 Too many calls from this address without a valid API key. | Twenty refused calls without a valid key in ten minutes from your address. | Fix the key first, then wait for Retry-After. |
| 503 This API key is not pointed at a current user… | Acts as is empty or that user was deactivated. | Set Acts as to an active user on API Clients. |
| 400 No account was identified for this request. | A multi-tenant deployment, and nothing named the account. | Send X-TMULTI-Tenant: <account> (the panel adds it), or use <account>.<host>. |
| 404 No account was found at this address. | A multi-tenant deployment, and the account named does not exist there. | Check the account name: it is the first part of the account’s own address. |
| 405 This MCP server is request/response only… | A GET (an event stream) after a valid key. Normal for clients that try one; they fall back to POST. | Nothing, unless your client refuses to continue: use a client with streamable HTTP support. |
tools/list answers no tools | The key is valid and nothing it was granted is an active exposure with Offer as an MCP tool ticked. | Grant an exposure, tick Offer as an MCP tool, make it active. GET /api/v1 with the key says how many resources it reaches. |
Tool result isError: There is no tool called "…" | The name is not in this key’s tools/list (a typo, or a tool from another key). | Call tools/list and use a name from it. |
Tool result isError: This key may not <verb> …, No … with that id is published here. | A refusal by the grant, the exposure or the row filter, or the screen’s own validation. | Read the sentence: it names the verb, record or field. |
| JSON-RPC error -32601 | A method this server does not implement (resources, prompts, sampling…). | Only initialize, ping, tools/list and tools/call exist. |
An HTTP refusal is JSON: {"error": "a sentence saying what was wrong"}; a 401 also carries WWW-Authenticate: Bearer.
Security
- This help site never sees your key. The Make your link panel fills the snippets in your browser; nothing is sent or stored.
- A key is shown once, when it is issued; TRANXACT keeps only a digest it can check against, and the last four characters to tell keys apart.
- Revoke it on Platform › Connectivity › Published API › API Clients: Withdraw key stops it at once and leaves the client on file; Issue key replaces it. Suspend the client to stop it without losing the key.
- Keep configuration files with keys out of version control (
.mcp.json,.cursor/mcp.json,.vscode/mcp.json). In VS Code, prefer the prompted variant below, which keeps the key out of the file. - Make the Acts as user narrow, keep Only from allowed addresses on, put an Expires date on keys and grants, and write What to tell an MCP client: it is the only place a model is told these tools reach a live ledger.
- A write through MCP is a write to a live business system. Clients ask before calling tools not marked read-only; leave that prompt on.
The other endpoint: TRANXACT delegated work. All endpoints and deployments: MCP links.