Integration

Entity Bind and Cursor

Shipped integration

A shipped integration: Cursor reads MCP servers from a JSON file in the same `mcpServers` shape every other client uses, at project scope inside the repository or at user scope for every project at once. The first block below — a URL and a token presented unchanged on every request — is the whole configuration; if your Cursor build keeps credentials in a vault rather than in the server entry, the second block is the shape that vault expects.
What this is
A shipped integration
Steps to working
4 below
Limits
3 below
Written back to your systems
Nothing
to installA JSON object
Before you build any of it
The answers land on your own rows before any code does, and looking costs no integration work.
Start free →

How you get a key

Create your workspace online and verify your email, then create your own read or resolve API keys, each shown once and revocable. Free includes 300 credits and needs no card. Paid subscriptions are purchased through Stripe in Billing, with applicable VAT and no automatic usage or overage charges.

host.example.com is a placeholder everywhere below, and a client configured against it will not connect. The hosted base URL is https://app.entitybind.com. Replace the placeholder with that origin; registry checks follow your activated plan.

The full-pipeline evaluation is arranged separately and is not activated by signup. Request it for your workspace; we confirm availability, sources and the start date before activation. It starts with a conversation about your file.

Create your workspace online, verify your email and create your own API key. Free includes 300 credits and shallow matching with no card; choose a paid subscription in Billing when you need registry checks.

Start free
On this page
setup, in 4 steps

Getting Cursor answering

Every block below is the shipped server's own configuration. The identifiers a running process actually reads — module paths, environment variable names, header names — are exact; the values beside them are placeholders, and the key under mcpServers is a display name that nothing on either side of the wire reads.

  1. 01

    Prove the endpoint answers

    Same first move as any client, and for the same reason: it separates a configuration problem from a reachability problem before you have spent an afternoon on the wrong one. A 421 Invalid Host header is refused before authentication and before routing, so no amount of editing the client config will clear it.

    Prove the endpoint answers
    curl -s https://host.example.com/healthz
    
    curl -s https://host.example.com/mcp \
      -H "Authorization: Bearer $ENTITYBIND_API_KEY" \
      -H "Content-Type: application/json" \
      -H "Accept: application/json, text/event-stream" \
      -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
  2. 02

    Add the server at project or user scope

    Project scope keeps the server with the repository it belongs to; user scope makes it available everywhere. The object is identical either way, and the key under mcpServers is the display name.

    Add the server at project or user scope
    {
      "mcpServers": {
        "entitybind": {
          "type": "http",
          "url": "https://host.example.com/mcp",
          "headers": {
            "Authorization": "Bearer rk_YOUR_KEY_HERE"
          }
        }
      }
    }
  3. 03

    Or, if the client stores credentials separately

    Clients that keep secrets out of the server config hold them in a vault keyed by the server URL, with a credential type per entry. A token presented unchanged on every request is what a vault calls static_bearer. The URL in the credential entry has to be byte-identical to the one in the server entry, trailing slash included: if it is not, the vault finds no credential, the client presents none, and what you see is an unauthorised response rather than a configuration error the client can describe.

    Or, if the client stores credentials separately
    {
      "mcpServers": {
        "entitybind": { "type": "http", "url": "https://host.example.com/mcp" }
      },
      "mcpCredentials": {
        "https://host.example.com/mcp": {
          "static_bearer": "rk_YOUR_KEY_HERE"
        }
      }
    }
  4. 04

    Tell the agent what an abstention is

    Put two things in the agent's own instructions before it calls anything. An abstention is a successful answer rather than an error: the tool returns a ranked shortlist, a typed reason, the column that would have decided, and a review id, and it costs nothing. And a confidence number is read against the recorded evidence behind that particular decision, not as a universal score. Confidence bounds depend on the recorded evidence population; there is no universal score for every match. Read match_confidence_basis and the evidence. A 0.99 filter can return some v8 adjudicated matches while excluding valid identifier matches, so validate its coverage cost on your own inputs.

If a step above fails against your own deployment, send us what the client reported rather than working around it.

Talk to us
what you get

What this route gets you

Every surface runs the same pipeline: the same cascade, the same confidence floor, the same evidence and the same credit rule. These are the things this route adds on top of it.

  • The eleven tools inside the editor, so a company identity question is answered where the code that depends on the answer is being written.
  • Free, unmetered reads for get_entity, get_crosswalk, get_enrichment_fields, search_entities, get_decision and get_usage — an agent can inspect the catalogue at no cost before deciding to resolve.
  • A decision id per resolve that reopens the full evidence trail at a URL, which survives the editor session.
limits

What it will not do

3 properties to build around, rather than to meet later in a client's logs. Each one changes what an agent or a repository can safely do on this surface.

  • 01

    The key sits in a config file. Project scope means that file is in the repository, so prefer user scope or a vault entry unless the repository is one where a credential is already acceptable.

  • 02

    Rate limits are per tenant across every surface at once, so an editor agent and a batch job share one budget.

  • 03

    The credential's plan caps depth before the cascade runs. A key capped at the probabilistic stage abstains rather than reaching adjudication, which saves money and never lowers precision — the alternative to a deep answer is unresolved, not a cheap guess.

Check these integration limits before building. Create your Free workspace to inspect your own rows and keys; contact us if you need help choosing a supported integration shape.

Start free

The other ways in

3 of the 6 are shipped integrations and 3 are patterns over the HTTP API. Every card says which kind it is, so you know what you are scoping before you open it.

Cursor sits with Claude Code and Claude Desktop on the same shelf: configure and call. If you are weighing a shipped integration against a pattern, the line between the two shelves is drawn on the hub.

Whichever surface you land on, the cheapest first move is the same: a few hundred of your own rows.

Start free
the ask

Start with a file, not an integration.

Create your workspace, verify your email and run your first company file. The Free plan needs no card. Create API keys in your workspace when you need an integration.

300 credits. No card.

For a guided review of your file, explore the Merge Safety Sprint →

Questions about Cursor

Can I use the same key in Cursor and in my application?

You can, and there is one thing to know before you do. Rate limits are bucketed per tenant rather than per key, because a limit a customer can multiply by minting a second key is not a limit — so an editor agent and a production job share one per-minute budget rather than getting one each. Separate keys are still worth creating in your workspace for a different reason: the ledger records the key id on every row, so two keys give you two readable columns in a usage export.

What happens if the model asks for something out of scope?

It gets a refusal shaped like a scope statement rather than a bad answer. Entity Bind resolves companies and organisations only. It does not resolve people, vessels, bank-account ownership, sanctions exposure, emissions or geolocation, and its results may not be used for eligibility decisions about individuals, including employment, credit and tenancy. An agent that needs one of those needs a different tool, and it costs less to say so in the agent's own instructions than to have it find out halfway through a task.