MCP Server

Tendios exposes an MCP (Model Context Protocol) server so AI assistants and agents can query public procurement data and your own pipeline directly, without you writing any HTTP integration code.

MCP is an open standard for connecting language models to external tools. Once the Tendios server is connected, your assistant can search tenders, pull a tender's full details, resolve CPV codes, look up contracting authorities, read your alerts and opportunity pipeline, and — with your confirmation — create alerts, move opportunities between stages, and add tasks, all as a natural part of the conversation.

The server wraps the same v1 use cases as the REST API and returns the same versioned response contracts. You can connect in two ways: sign in with your Tendios account (OAuth), which is what assistants such as Claude use, or send an API key for scripts and headless agents.

Endpoint

https://mcp.tendios.com/api/mcp

The server speaks the Streamable HTTP transport. It runs in stateless mode — a fresh server instance is built per request, so there are no sessions to manage and no session affinity required.

Property	Value
Server name	tendios-mcp
Server version	1.0.0
Transport	Streamable HTTP
Authentication	OAuth 2.1 (sign in with Tendios) or API key
Tools exposed	24

Requirements

MCP access is enabled per account by the Tendios team. Your account has MCP access once it has an API key with the MCP capability enabled:

1. Have an API key. If your plan includes API access you can generate one yourself — see Authentication. API access is available on Enterprise plans.
2. Ask us to enable MCP on that key by contacting support@tendios.com. The flag is set by the Tendios team and can't be turned on from the app.

From then on, members of the account can connect an assistant by signing in once MCP access is enabled for them (see Who can connect), and that key can also be used directly. If the key is disabled, deleted or loses the MCP flag, signed-in connections to that account stop working too.

Connecting with your Tendios account (OAuth)

This is the recommended way to connect an assistant. You only give the client the server URL; it opens a browser window where you:

1. Sign in with your Tendios email and password, or with Google or LinkedIn.
2. Choose the account the assistant will act for, if you belong to more than one. Only accounts with MCP access are listed.
3. Approve the access the assistant asks for.

The client receives short-lived tokens bound to you and to that account, and refreshes them on its own. You never copy a secret into a config file.

Claude (claude.ai and Claude Desktop)

Add Tendios as a custom connector from Claude's settings, under Connectors, using the URL https://mcp.tendios.com/api/mcp. Then select Connect and complete the sign-in. On Team and Enterprise plans, an owner may need to add the connector for the organization first.

Claude Code

claude mcp add --transport http tendios https://mcp.tendios.com/api/mcp

Then run /mcp inside Claude Code, select tendios and choose Authenticate to open the sign-in page.

Other clients

Any client that implements the MCP authorization specification can connect with just the URL — for example:

{
  "mcpServers": {
    "tendios": {
      "type": "http",
      "url": "https://mcp.tendios.com/api/mcp"
    }
  }
}

Read and write access

Signing in grants one or both of these scopes, which the consent screen shows:

Scope	Access
mcp:read	Public procurement data and your account's data. Write tools are hidden.
mcp:write	Also the write tools: create alerts and tasks, move opportunities.

A connection can write only when both are true:

• you approved mcp:write when signing in, and
• your account's MCP-enabled API key has write access (keys are read-only unless set otherwise; see Read-only and full-access keys). If the account has several MCP keys, one with write access is enough.

Otherwise the connection is read-only and does not see the write tools at all. Changing the key's access applies to signed-in connections on their next request.

Who can connect

• Members of an account with MCP access, once MCP access is enabled for them. This applies to every member, account admins included. An account admin can turn it on (or off) for each member from Settings → Users in Tendios (the MCP column and the member's actions menu), or you can ask support@tendios.com.
• Access always follows your current membership and settings: if you are removed from the account, your user is deactivated or your MCP access is turned off, the assistant's next request is rejected, even with a valid token.
• Users with two-factor authentication enabled on Tendios can't sign in to the MCP yet. Use an API key instead in the meantime.

To revoke an assistant's access, contact support@tendios.com: we can disable the connection immediately, which also revokes its tokens.

How clients discover the sign-in

This is handled by MCP clients and only matters if you are building one. Requests without credentials get 401 Unauthorized with a challenge pointing to the protected resource metadata (RFC 9728):

WWW-Authenticate: Bearer resource_metadata="https://mcp.tendios.com/.well-known/oauth-protected-resource/api/mcp", scope="mcp:read mcp:write"

Item	Value
Resource	https://mcp.tendios.com/api/mcp
Authorization server	https://api-rest.tendios.com/api/identity
Server metadata	https://api-rest.tendios.com/.well-known/oauth-authorization-server/api/identity
Grant	Authorization code with PKCE (S256), plus refresh tokens
Client registration	Client ID Metadata Documents, or dynamic client registration (RFC 7591)
Scopes	mcp:read, mcp:write, offline_access

Access tokens are JWTs issued for the MCP resource (aud), and the server verifies them on every request. Send them as Authorization: Bearer <token>.

Connecting with an API key

For scripts, CI jobs and agents without a browser, send an MCP-enabled key in the api-key header on every request. There is no token exchange.

api-key: tend_your_api_key_here

A key can only reach its own account's data. Account-scoped tools resolve the account from the key — you never pass an account id. Call whoami to see which account, organization, and plan a key resolves to.

Most MCP clients use the same mcpServers configuration shape; add the key as a header:

{
  "mcpServers": {
    "tendios": {
      "type": "http",
      "url": "https://mcp.tendios.com/api/mcp",
      "headers": {
        "api-key": "tend_your_api_key_here"
      }
    }
  }
}

In Claude Code this goes in your project's .mcp.json (or add it with claude mcp add --transport http tendios https://mcp.tendios.com/api/mcp --header "api-key: tend_your_api_key_here"). Restart the client after editing the file, then confirm the tendios server is listed as connected.

New keys are read-only: they only see the read tools. Allow writes on the key in its settings if the assistant should be able to create alerts and tasks or move opportunities.

A key without the MCP flag is rejected with 403 Forbidden:

{
  "statusCode": 403,
  "message": "API key is not enabled for MCP access"
}

Treat the config file as a secret

Your API key sits in plain text in these config files. Don't commit them to a public repository. If a key leaks, you can disable or delete it yourself and generate a new one, or contact support@tendios.com to have it rotated.

Verifying the connection

To check the endpoint outside a client, post a JSON-RPC request directly. MCP clients perform the initialize handshake for you; because the server is stateless you can also call methods without carrying a session id:

curl -X POST https://mcp.tendios.com/api/mcp \
  -H "api-key: tend_your_api_key_here" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{ "jsonrpc": "2.0", "id": 1, "method": "tools/list" }'

A healthy server responds with the list of available tools and their input schemas.

Available tools

Twenty-four tools are exposed: nine read public procurement data, ten read data scoped to your account, four write to it, and find_tools helps the assistant pick the right one. See MCP Tools for the list and each tool's parameters.

Start with list_pipelines and whoami

The kanban and opportunity tools need pipeline and stage identifiers. Rather than making you look them up, list_pipelines returns every pipeline with its stages, and the kanban tools accept either a UUID or the exact pipeline or stage name it returned. whoami confirms which account the assistant is acting on. Together they let an assistant orient itself in two calls before touching anything.

Response format

Every tool returns its payload as JSON inside a single text content block:

{
  "content": [{ "type": "text", "text": "{\"id\":\"507f1f77bcf86cd799439011\", ... }" }]
}

The JSON inside text follows the same v1 response contracts as the REST API, so a field means the same thing whether you reached it through MCP or through GET /v1/tenders/{id}. Paginated tools return the familiar { data, pagination } envelope described in Pagination.

References

Most tools also return a structuredContent.references object alongside the text. Each reference is a { type, id, label } triple naming an entity the assistant can feed straight into a follow-up tool call, so it never has to parse IDs back out of prose:

{
  "references": {
    "alerts": [
      { "type": "alert", "id": "507f1f77bcf86cd799439011", "label": "IT services in Madrid" }
    ]
  }
}

Reference types are tender, alert, organization, pipeline, pipeline-status, opportunity, and task.

Tools that take an entity as input are correspondingly forgiving: the alert and opportunity parameters accept a reference ID or a Tendios URL pasted from the browser, and pipeline and stage parameters accept a UUID or the exact name from list_pipelines.

Rate limits

The MCP server is rate-limited per account: every API key and signed-in connection of an account shares one budget. The default is 30 requests per minute; a key with its own configured limit uses that limit for its requests.

HTTP/1.1 429 Too Many Requests

One budget for every tool

Unlike the REST API, where each endpoint has its own budget, every MCP message (initialize, tools/list and each tool call) counts against the same per-account budget. If your agent workload needs more, contact support@tendios.com to raise the limit.

Exceeding the limit blocks further requests for the remainder of the 60-second window.

Errors

Authentication and authorization failures use standard HTTP status codes; tool-level failures come back as MCP error results.

Code	Meaning
401	No credentials, an invalid, expired or disabled API key, or an invalid or expired access token. Includes the WWW-Authenticate challenge
403	Valid credentials without MCP access: the key doesn't have MCP enabled, the account has no MCP access, you are no longer a member of the account or your user is deactivated, or the connection was disabled
429	Rate limit exceeded for the account

See Errors for the shared error body shape.

Writing data

The MCP server is no longer read-only. Four tools write to your account:

Tool	Writes	Guard
create_alert	Creates an alert	Requires confirmed: true
update_alert	Changes fields on an existing alert	Idempotent; omitted fields stay as they are
change_opportunity_status	Moves an opportunity to another stage	Requires confirmTerminal: true for terminal stages
create_opportunity_task	Adds a task to an opportunity	Requires confirmed: true

Nothing deletes. There is no tool that removes an alert, opportunity, or task — the most destructive action available is moving an opportunity into a terminal stage, which closes it.

Two-step confirmation

create_alert and create_opportunity_task refuse to act on the first call. Invoked without confirmed: true, they return an error result instructing the assistant to summarize what it is about to create and ask you to approve it; only a second call carrying confirmed: true performs the write. change_opportunity_status works the same way for terminal stages via confirmTerminal, and short-circuits harmlessly when the opportunity is already in the requested stage.

This puts the approval step inside the protocol rather than relying on the client to ask. Clients that surface MCP tool annotations will also show these four as non-read-only, with change_opportunity_status flagged destructive.

Read-only access

For an assistant that can only look, keep the account's MCP key read-only, or approve only mcp:read when signing in. The write tools are then hidden from the assistant.

Not available as tools

• Tender sheet file download — binary streams don't map onto MCP tool results. Use get_tender_sheets, which returns short-lived Tendios download links, and fetch the file over HTTP.
• API key lifecycle metadata — whoami deliberately exposes only safe caller context (principal, account, organization, plan). Key prefixes, expiry, and rate limits are not reachable from MCP; use GET /v1/api-key for those.