Integration

Entity Bind and Salesforce

Pattern over the HTTP API

This is an integration pattern over the HTTP API, not a shipped connector. There is no package, no managed application, no marketplace listing and nothing to install: what is described below is the shape of the integration you would build, written down because knowing the shape in advance is most of the work. The CRM route stays read-only on your side: a named credential holding the API key, a callout that resolves an account, and a set of custom fields that record what came back. Entity Bind writes nothing to your CRM at any point. The first thing a duplicate-account project needs is an answer nobody has acted on yet.
What this is
A pattern you build
Steps to working
4 below
Limits
5 below
Written back to your systems
Nothing
to installNothing at all
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

What you would build for Salesforce

There is nothing to install, so the blocks below are the job itself: the query, the request, and the branch on what comes back. Endpoint paths, header names and field names are the API's own and are exact — the code around them is a shape to fit to your own stack.

  1. 01

    Start with an export rather than a callout

    Most Salesforce conversations should start as a file rather than as an integration, because the interesting output arrives before any code does. Send us a file. We tell you which of your rows are the same company, which of your existing matches are wrong, and what we could not decide — and we write nothing to your systems. The audit pack: twelve files, a receipt per decision, and a report that opens offline. Build the callout once you have seen what the answers look like on your own accounts.

  2. 02

    Hold the credential where Salesforce holds credentials

    A named credential holding the base URL and the Authorization header keeps the key out of Apex source and out of a custom setting a support user can read, and makes it rotatable without a deployment. The key you create in your Entity Bind workspace is the whole credential: there is no separate exchange step, no secondary token and no MCP-specific credential.

  3. 03

    Resolve, and record the receipt

    One callout per account, or a batch of up to 500 for a bulk pass. The fields worth adding to the account object are the ones that make the answer auditable later: the entity id, the match confidence, the decision id, and the typed reason where the record did not resolve. The decision id is the one people leave out and the one that matters — it reopens the whole evidence trail at a URL long after whoever ran the job has moved on.

    Resolve, and record the receipt
    {
      "client_ref": "0018d00000ABCDEAA1",
      "name": "Acme Widgets Ltd",
      "domain": "acmewidgets.co.uk",
      "country": "GB",
      "postal_code": "EC1A 1BB",
      "depth": "research"
    }
  4. 04

    Route abstentions to a queue, not to a default

    A match below 0.90 confidence is unrepresentable. The record comes back as an abstention with a ranked shortlist instead. What comes back instead is a ranked shortlist, a typed reason, the column that would have decided the record, and a review id — and it costs nothing. Route those to a queue where a person sees the shortlist. The failure to design out is the familiar one: taking the top shortlist row because a field needed a value.

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.

  • Duplicate accounts identified in your own record ids, with a receipt per decision that reopens at a URL.
  • The merges we refused, and why. One disagreeing strong identifier blocks a merge outright — a company number, an LEI — and so do two or more disagreeing weak signals, such as a domain and a phone number together.
  • An independent second opinion on matches your incumbent proposed: we accept, withhold or contradict them, and report which, per provider and per jurisdiction.
  • A work list rather than a silence: every unresolved account carries a typed reason and, wherever a column is nameable, the name of the field that would have settled it.
limits

What it will not do

Start with the first one: it decides whether there is anything to install at all. The rest are the parts of the shape that most often get scoped wrong.

  • 01

    This is an integration pattern over the HTTP API, not a shipped connector. There is no package, no managed application, no marketplace listing and nothing to install: what is described below is the shape of the integration you would build, written down because knowing the shape in advance is most of the work.

  • 02

    No managed package and no AppExchange listing. There is nothing to install, and no security review has been undertaken because there is nothing to submit to one.

  • 03

    We write nothing to Salesforce at any point. Merging accounts stays your operation in your system, which is the right way round for an action that is irreversible in the target.

  • 04

    We do not promise a count of dangerous merges prevented, and you should distrust anyone who does before they have seen your file. Zero is a normal, honest result: two rows carrying contradicting company numbers are refused outright and never reach the guard that would have counted them.

  • 05

    Person accounts and contacts are out of scope. Entity Bind resolves companies and organisations only, and a contact-level deduplication problem needs a different tool.

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.

Salesforce sits with Snowflake and Python on the same shelf: nothing to install. 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 Salesforce

Will Entity Bind merge our Salesforce accounts for us?

No. We tell you which of your rows are the same company, which of your existing matches we would not have made, and which we could not decide — in your own record ids, with a reopenable receipt for each. Merging is an irreversible write in your system, and the party that proposed a merge should not be the party that performs it. That separation runs inside the product too: the credential that approves a merge is not the credential that proposed it.

How does this compare with the native duplicate rules?

The native rules score how alike two strings look, which is a statement about the strings rather than about how often decisions like this one turned out right, and they write with no evidence attached — so six months later the answer to "why did these two accounts become one" is that a rule scored 0.87 and somebody clicked. The difference here is not a higher score. It is that the score is measured against labelled outcomes, that nothing below the confidence floor can come back as a match at all, and that every decision leaves a receipt you can reopen. Run the comparison on your own export, and look first at the rows we refused.