Connect an AI assistant (MCP)

Notificado has three MCP servers, one per kind of account. Each has its own address, its own tokens and its own tools; a token for one opens none of the others.

Most of this guide is for firms. Affiliates have their own section, Affiliates, and a full guide, MCP for affiliates.

Firms: /mcp

The firms' MCP server is at https://www.notificado.co/mcp (JSON-RPC over HTTP). A connected assistant can look up cases, prepare drafts, upload documents, check deliveries and download evidence, depending on its token's scopes. It never sends on its own. How it works: How the assistant works.

Recommended: sign in with OAuth (no token)

Claude Code

One command, with no header:

claude mcp add --transport http notificado https://www.notificado.co/mcp

The first time you use it, Claude Code opens your browser. Sign in as a firm owner or lawyer, check which application is asking, choose the scopes and press Allow. That is all: there is no token to copy or store.

The connection stays active while you use it: Claude Code renews it by itself, and each use restarts the period. After 60 days without use the connection closes; that period is fixed. If it closes, Claude Code asks you to sign in again. It shows under Account → API with the client's name, and you revoke it there at any time.

Claude.ai, Claude Desktop, ChatGPT

Clients that add MCP servers as connectors do the same:

1. In your client, add a custom connector with the address https://www.notificado.co/mcp (in Claude: Settings → Connectors → Add custom connector).
2. The client sends you to Notificado. Sign in, check which application is asking, choose the scopes and press Allow.
3. Done: the connection appears under Account → API with the client's name, and you revoke it there.

Notificado does not verify the name an application states: allow only a connection you started. No connector ever gets Notificado staff tools.

For something more durable: a personal token

For CI, a script or a tool that runs with nobody at the browser, use a personal token. You choose its lifetime when you issue it: 30, 60, 90, 180 or 365 days, a specific date (it expires at the end of that day, Colombian time), or no expiry. A token with no expiry works until someone revokes it: use it only for an integration you control. Under Account → API you see when each token was created, its last use and its expiry, you can change the expiry, and you revoke it at any time.

1. Issue a token

Under Account → API (/cuenta/api) create a token with the narrowest scopes that do the job. An assistant that only reports needs cases:read and notifications:read. Details in API authentication.

2. Connect your client

Notificado requires the token in an Authorization: Bearer header. These clients support that for remote HTTP MCP servers:

• Claude Code, with one command:

claude mcp add --transport http notificado https://www.notificado.co/mcp --header "Authorization: Bearer <token>"

• Claude Desktop: through the mcp-remote bridge (needs Node.js), in its configuration file.
• Cursor: by URL and headers, in mcp.json.

The exact Claude Desktop and Cursor configuration, ready to copy, is on the MCP page.

3. Test the connection

Ask the assistant to call whoami({}): it answers your firm (orgId), your role, the token's scopes, its prefix and its expiry. Then list_resources({}): the resources the token may use. And docs({}): the index of recipes and guides the server itself provides.

How the assistant works

Every token sees the same five tools, whatever its scopes:

The firm's actions are not separate tools: each sits in a resource and runs through manage_resource, under the same scopes, rules and activity log as in the panel. On connecting, the server tells the assistant to call whoami first and then list_resources. The order is always the same:

list_resources({})                                   // what there is
describe_resource({ resources: ["cases"] })          // the exact parameters
manage_resource({                                    // run
  resource: "cases",
  action: "caseList",
  params: { orgId: "<orgId>", q: "05001310300320260012300" },
})

The orgId is the one whoami answers. The resources, and what each holds:

• cases: the firm's cases. Search by radicado, cliente, juzgado or party; register, correct, archive and reopen.
• parties: a case's parties and their saved addresses, with where each came from. Saving an address is not the art. 8 sworn statement.
• uploads: upload a PDF, PNG or JPEG. A signed URL for the PUT, then a confirmation that checks the type and records the SHA-256.
• imports: import a CSV of cases and drafts, see what each row became, download the failed rows and follow the batch sends.
• notifications: notifications and their drafts. List, read each recipient's timeline, draft, attach, check an address, discard a draft, see bounces, export to Excel, read the credit balance and verify a constancia.
• sends: request a send and follow the pending requests. No request sends by itself.
• memorials: the memorial for the juzgado, as a DOCX and PDF draft, and its download. Nothing is filed: you review, sign and file it.
• court-outcomes: what the juzgado decided about a notification (accepted, rejected, nulidad). It is not evidence.
• templates: the firm's message templates. The art. 8 statements are always appended and no template replaces them.
• evidence: the signed constancia PDF and the evidence .zip package. Each download is recorded.
• deadlines: the computed terms per recipient and the juzgado closures they skip. An estimate: the judge decides.
• billing: the firm's credit statement and electronic invoices. An agent does not buy credits.
• activity: who in the firm did what, newest first.
• webhooks: the firm's outbound webhooks and their delivery log. Owner tokens only.

Each token sees only the resources and actions its scopes open. The descriptions list_resources gives are in English: they are what the assistant reads. Every action is also an operation of the HTTP API.

Confirm before sending

1. The assistant prepares the case, the draft and the attachments.
2. You add the recipients in the panel, with the art. 8 sworn statement.
3. The assistant requests the send with manage_resource({ resource: "sends", action: "sendNotification", params: { … } }): the answer is awaiting_confirmation with a link.
4. You open the link and confirm in the panel within 24 hours. Only then are credits consumed and the message frozen, timestamped and sent. What nobody confirms in that time expires: nothing is sent and no credit is used.

The requests waiting for your confirmation show in the panel, and the assistant reads them in sends (recipe Confirm pending sends).

Limits

120 reads and 20 writes a minute per person, across all their tokens. See Limits.

Affiliates: /mcp/afiliados

An approved affiliate can connect an assistant to their own program account at https://www.notificado.co/mcp/afiliados. The assistant sees only that account: never a firm, its cases or another affiliate's account.

1. On /afiliados, section Agent access (MCP and API), create a token: a name and its scopes. The token is shown once.
2. Connect your client with that token:

claude mcp add --transport http notificado-afiliados https://www.notificado.co/mcp/afiliados --header "Authorization: Bearer <token>"

In Claude Desktop, through mcp-remote:

{
  "mcpServers": {
    "notificado-afiliados": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://www.notificado.co/mcp/afiliados", "--header", "Authorization:${AUTH_HEADER}"],
      "env": { "AUTH_HEADER": "Bearer <token>" }
    }
  }
}

Always in person, never by an agent: applying and accepting the terms, the identity and tax verification, the payout account, and confirming an invoice. The full detail, with the equivalent API, is in MCP for affiliates.

Notificado team: /mcp/admin

https://www.notificado.co/mcp/admin is for Notificado staff only, with tokens issued in the internal console. A firm or affiliate token opens nothing there, and a staff token that calls /mcp is refused with a pointer to /mcp/admin. Every write by a staff agent waits for a person on the team to confirm it before it runs.