Skip to content

MCP server ​

The Nimobase MCP server connects your AI agent — Claude Code, Cursor, Codex, opencode, Cline — to your company. Ask it things in plain language — who's in your account, what invoices landed this month, send the team a notification — and the agent does it for you, with your permissions. MCP (Model Context Protocol) is simply the standard that lets an AI agent use external tools like this one.

Before you start ​

  • An MCP-capable client: Claude Code, Cursor, Codex, opencode or Cline. Any of them works.
  • A Nimobase account with an active company (or an API key for that company, if you prefer the local connection).
  • Your same permissions, not one more: the server has no privileges of its own. Whatever your account or key can't do, the agent can't either.

Connecting ​

Nothing to install: register the endpoint in your client and authenticate once.

EnvironmentURL
Productionhttps://mcp.nimobase.com/mcp
Sandboxhttps://mcp-sta.nimobase.com/mcp

Register it under the key nimobase — not mcp, not nimobase-mcp. Other MCP servers on your machine commonly use those generic names, and a duplicate key makes the client silently shadow one entry.

The first time you use it, this is what happens:

  1. Your client opens a browser.
  2. You sign in to Nimobase and pick the company.
  3. You see, in human language, which actions are requested — and approve them.
  4. Your client stores the access: you don't repeat this until it expires.

If your client can't run a browser flow, you can hand it the token directly in an Authorization: Bearer … header.

Claude Code ​

bash
claude mcp add --transport http nimobase https://mcp.nimobase.com/mcp

Then, inside Claude Code: /mcp → nimobase → Authenticate, and follow the browser flow. On a headless machine, claude mcp login nimobase does the same from the shell.

Local (stdio) ​

If you'd rather run a process on your own machine, add this to your client's MCP configuration:

json
{
  "mcpServers": {
    "nimobase": {
      "command": "node",
      "args": [
        "/absolute/path/to/packages/mcp-server/dist/bin/nimobase-mcp.js"
      ],
      "env": {
        "NIMOBASE_API_KEY": "sk_…"
      }
    }
  }
}
VariableRequiredWhat it's for
NIMOBASE_API_KEYyesYour sk_… or pk_… key. It decides what the agent can see and do — same as the SDK
(none)noWith no variables set, the server talks to Production
NIMOBASE_SANDBOXnoSet it to true to work against Sandbox
NIMOBASE_BASE_URLnoEscape hatch: if set, it wins over the above and points at the API you give it

To work against Sandbox, add that variable to env; without it, you go to Production:

json
{
  "mcpServers": {
    "nimobase": {
      "command": "node",
      "args": [
        "/absolute/path/to/packages/mcp-server/dist/bin/nimobase-mcp.js"
      ],
      "env": {
        "NIMOBASE_API_KEY": "sk_…",
        "NIMOBASE_SANDBOX": "true"
      }
    }
  }
}

If the key is missing, malformed, expired or revoked, the process won't start and says why — so an agent never sees a half-working tool list.

This configures the local process: the agent talks to the Sandbox API. With the remote transport the environment is not chosen with this variable but with the endpoint URL in the table above: they are two different paths, not two ways of doing the same thing.

Using it ​

Once you're connected, just ask. The agent picks the right tool, runs it with your permissions and reports back. For example:

  • "List the users in my company" → users_list
  • "Invite ana@example.com as a MEMBER" → invitations_create
  • "What invoices do I have this month?" → billing_list_invoices
  • "Send the team a notification about the maintenance window" → notifications_send
  • "Check that the connection works" → whoami
  • "Generate a TypeScript SDK client in this project" → scaffold_integration

What it can do ​

The tools cover the product's features. Names follow the <module>_<action> pattern, so the agent can guess them without reading a catalogue:

FeatureWhat it solves
UsersThe people in your company: list, view, create, update
CompaniesYour company: its details, its members, adding people
NotificationsSending, scheduling and tracking notifications; managing devices
BillingSubscription, invoices, entitlements, checkout and payment portal
InvitationsInviting people and managing pending invitations

A few things worth knowing:

  • Nothing destructive runs without confirmation. Deleting, cancelling a subscription or revoking an invitation requires confirm: true in the call; without it the action is rejected before anything is touched.
  • whoami confirms the connection is alive and which key type it uses.
  • scaffold_integration leaves a working SDK client (TypeScript, Python or browser) in your project. It writes files and never calls the API; if an integration already exists, it's left alone.
  • The server also ships integration guides the agent can read on its own, so it writes correct code without you pasting context into the chat.

Errors ​

When something fails, the agent sees it exactly as the API returned it: validation, permissions, not found or rate limit, with the original HTTP status and message. Errors are never dressed up — they're passed through.

Scope and versions ​

The tools cover the six SDK v1 modules. AI, Webhooks and API Keys don't have a tool yet. The @nimobase/mcp-server package is published in lockstep with @nimobase/sdk: any MCP version ships with the SDK it was built and tested against.

Status

The client configurations above were checked against each harness's official documentation on 2026-11-02; they have not been exercised end to end against a deployed endpoint. The remote deployment is tracked separately from the package.