Apollo.io Salesforce Integration for Lead Routing
Apollo can enrich the record. The harder question is where that Salesforce lead belongs. Build an auditable handoff that enriches, routes, and records the decision before the first rep gets the lead.

TL;DR: what you'll build. Apollo.io enriches a prospect with company and title data, but deciding which Salesforce territory and rep owns that person is a manual judgment call today, usually made by an SDR manager eyeballing a spreadsheet once a day. This guide shows how to build a Major app that holds the Apollo-to-Salesforce handoff as durable state: a scheduled workflow pulls newly enriched Apollo people, an agent judges only the ambiguous territory and low-confidence matches, and a deterministic routing engine creates the Salesforce Lead with an owner, a rule version, and a rationale attached. The SDR manager approves exceptions instead of reviewing every lead.
The lead-routing problem: enrichment is not assignment
The SDR manager or lead-routing admin owns this gap. Apollo.io finds and enriches a prospect: title, company, domain, headcount. Salesforce needs that prospect turned into a Lead with a territory and an owner before a rep can work it.
Those are two different jobs. Apollo's own Salesforce integration can sync enriched fields into existing Salesforce records, but it is not a territory router. It maps fields; it does not decide who owns the record.
Picture a person named Dana Oyelaran, VP of Ops at a 300-person logistics company on a .com domain headquartered in Ohio. Apollo returns her title, company, and a match confidence score. Salesforce still needs someone to decide: is Ohio in the Midwest territory or the East region bucket this quarter, does this company already have an open deal, and which rep is next in line.
Today an SDR admin does that by hand, once a day, often from a spreadsheet of territory boundaries that nobody has reconciled with the CRM lately. New contacts sit in Apollo for a day or more before anyone looks at them. During a busy week, the admin falls behind and leads get routed to whoever remembers to check.
This process sits inside the broader shift toward AI agents for sales workflows, where the function hub covers outbound, pipeline, and CRM hygiene more generally. It is also one instance of a wider AI agents cross-industry pattern: enrichment from one system, a judgment call, and a write to a system of record. Two related builds worth comparing: one that automates an enriched lead handoff from ZoomInfo into outreach tooling, and one that routes stalled Salesforce opportunities back to a rep automatically. The fix is not more Apollo automation. It is a stateful decision layer that remembers every routing decision, applies the same rule every time, and only asks a person when the rule genuinely does not cover the case.
Systems and API objects in the Apollo-Salesforce handoff
Apollo.io: enrichment and search, not routing
Apollo's core objects for this workflow are people and organizations. Apollo's authentication docs confirm the API key goes in the x-api-key header, with OAuth 2.0 available for partner and ISV integrations rather than a typical end-user flow.
The two endpoints that matter here:
- People match, documented at
POST /people/match, the full path beinghttps://api.apollo.io/api/v1/people/match. It takes an email, name, or domain and returns apersonobject withmatch_confidenceofhigh,medium,low, ornone, plus title, organization, and employment history. - Organization search, documented at
POST /mixed_companies/search, the full pathhttps://api.apollo.io/api/v1/mixed_companies/search. It filters by domain, headcount, industry, and more, paginated withpageandper_page, and the docs state it costs 1 credit per page with up to 100 results per page.
Apollo has no documented webhook feed for new enrichment events as a primary feature, so this workflow polls on a schedule instead of reacting to a push. Think of polling like checking the mailbox at set times versus a doorbell: nobody rings when a new Apollo match appears, so the workflow has to go look.
The honest gotcha: Apollo's rate limits are shared across the whole team's API key, not per integration. The catalog notes free-tier limits around 50 requests per minute, 200 per hour, and 600 per day, with higher ceilings on paid plans, so a routing job sharing a key with your sales team's manual Apollo usage needs backoff logic, not a tight polling loop.
Salesforce: the Lead object and OAuth
Salesforce is the target system of record. The relevant object is the standard Lead, created or updated through the REST API. Salesforce's REST API guide documents the sObject Basic Information resource for creating a record with a POST to the sobjects endpoint for a given object, versioned in the path (for example /services/data/v62.0/sobjects/Lead/), which maps to the pattern Salesforce calls out across its sObject resources reference material.
Auth runs through OAuth 2.0 via a Connected App, which issues scoped tokens tied to an integration user rather than a shared admin login. Salesforce does not expose a native webhook for inbound REST calls, but it does offer Platform Events and Change Data Capture for event-driven notification outward, which this workflow does not need since it is writing, not listening.
Required fields and daily API call limits are both org- and edition-specific, so confirm the actual required fields on the target org's Lead layout (commonly Last Name and Company, at minimum) before the first write.
Regulation: no special carve-out here, but outreach consent still applies downstream
This workflow creates CRM records; it does not send outbound email or calls. CAN-SPAM and the sales function's documented TCPA rules govern what happens after a rep picks up the Lead, not the enrichment-to-routing step itself. If your downstream sequence tooling fires off the back of this Lead creation, make sure consent and opt-out state travel with the record rather than getting silently dropped at the handoff.
Architecture: the app, the agent, and the workflow
Three pieces do distinct jobs here, and keeping them separate is what makes the system auditable.

Architecture: Apollo enrichment feeds a Major app; an agent judges exceptions; approved routes write to Salesforce as Leads
The app is the control surface and the system of record for routing decisions. It holds four managed tables:
- LeadIntake: Apollo person ID, organization ID, normalized email, normalized domain, timestamp pulled, source list.
- EnrichmentSnapshot: the raw fields Apollo returned,
match_confidence, and when the snapshot was taken. - RouteDecision: territory assigned, proposed owner, rule version used, rationale text, and a review flag.
- SyncAttempt: Salesforce Lead ID, write status, error message if any, retry count.
The agent only runs when the deterministic rules in the app cannot resolve a case cleanly: a company with offices spanning two territories, a match_confidence of low or none, or a domain the territory map has no entry for. The agent reads the Apollo snapshot and the territory map, proposes a route with a short written rationale, and stops there. It never writes to Salesforce directly.
The workflow is the deterministic spine: poll Apollo on a schedule, normalize and dedupe, apply explicit territory rules first, call the agent only for the leftover cases, gate on approval when required, then write to Salesforce and log the outcome. This is the same split covered in Salesforce automation with an app layer: enrichment and matching are repeatable, so they run as app logic; only the edge cases spend a model call.
Why split it this way at all? Because every rule the workflow enforces runs the same way on the one-thousandth lead as it did on the first, while the agent's job shrinks over time as the territory map gets more complete and fewer cases fall through. That is also why this lives in an app rather than being re-reasoned by a model on every run: a model deciding "is Ohio Midwest or East" from scratch each time would be slower, costlier, and could answer differently from one run to the next.
Build Apollo-to-Salesforce routing on Major
- Connect the Apollo and Salesforce connectors. Salesforce has an official connector in Major's catalog; IT authorizes it once through OAuth with a dedicated integration user scoped to Lead read, create, and update only. Apollo has no official Major connector yet, so IT sets it up as a custom REST connector with base URL
https://api.apollo.io/api/v1and the API key stored in Major's central credential store, never pasted into a prompt or workflow step. You should see both connectors listed as shared, governed credentials any app or agent on the team can reference without re-entering a secret. - Build the Lead Router app with the four tables above: LeadIntake, EnrichmentSnapshot, RouteDecision, and SyncAttempt, plus a territory map table holding domain or region rules and a version number. Add a review queue screen that lists every RouteDecision flagged for review, with the Apollo snapshot and proposed route shown side by side. You should see a working queue table with a status column (
pending,approved,rejected,synced).
Example build prompt:
"Build an app called Lead Router with tables LeadIntake (apollopersonid, apolloorgid, email, domain, pulledat, source), EnrichmentSnapshot (leadintakeid, matchconfidence, title, companyname, rawfields, snapshotat), RouteDecision (leadintakeid, territory, proposedowner, ruleversion, rationale, reviewflag, status), and SyncAttempt (leadintakeid, salesforceleadid, status, error, retrycount). Add a queue screen filtered to reviewflag = true."
- Add the routing agent and scope its job narrowly. Give it read access to the app's territory map and EnrichmentSnapshot tables, and a single write action: propose a RouteDecision. It should never call the Salesforce connector directly. You should see the agent's proposed routes appear in the review queue with a rationale field filled in, never a silent write to Salesforce.
Example agent prompt:
"When a LeadIntake row has no matching territory rule, or its EnrichmentSnapshot matchconfidence is low or none, read the organization's domain, headcount, and region. Propose a territory and owner from the current territory map, write a one-sentence rationale, and set reviewflag to true. Never guess a territory that isn't in the map; if none fits, set status to unresolved and flag for manager review."
- Set the workflow trigger to a schedule, for example hourly, since Apollo documents no inbound webhook for new matches. The workflow calls Apollo's people match endpoint for a saved list of qualifying signups, normalizes email and domain, checks LeadIntake and Salesforce for an existing match, applies the territory map first, and only invokes the agent on remaining ambiguous cases. You should see a new workflow run logged every hour with a count of leads pulled, auto-routed, and sent to review.
- Test the workflow against a sandbox Salesforce org with a handful of seeded Apollo test contacts, including one duplicate, one clear-territory match, and one ambiguous multi-office company. You should see the duplicate skipped, the clear match auto-routed and written as a Lead, and the ambiguous case sitting in the review queue with the agent's rationale attached.
- Roll out with permissions: give the SDR manager role write access to approve or reject queued routes and edit the territory map; give reps read-only access to their own routed Leads; keep the Salesforce write credential scoped to the workflow's service identity only. You should see the audit log recording who approved which exception and when.

Data flow: deduplication and the approval path for ambiguous routes before a Salesforce write
Apollo's native sync and this app-layer workflow do different jobs, worth stating plainly:
- Apollo's native Salesforce sync maps enriched fields onto records that already exist or creates simple ones, following whatever field mapping is configured in the Apollo-Salesforce package.
- The Major app-layer design adds the piece Apollo doesn't do: durable routing state, a versioned territory rule, a logged rationale for every decision, and a review queue for the cases no rule covers.
Governance, failures, and edge cases
Access to the Lead Router app runs through Major's SSO and role-based access control, so an SDR rep can see their own routed leads without being able to edit the territory map or approve exceptions meant for a manager. Every API credential, the Apollo key and the Salesforce OAuth token, sits in Major's central credential store behind a credential proxy: no key ever appears in a workflow step, an agent prompt, or a log line. IT governs that proxy, not individual builders.
This kind of durable, permissioned build is what a governed software factory produces: a team describes the routing logic it needs, and the resulting app comes with audit trails and access control already attached, rather than a script someone's laptop runs unsupervised.
Every RouteDecision and SyncAttempt row is timestamped and attributed, giving a full audit trail of who or what made each call: a rule, the agent, or a manager's manual override.
Failure modes to design for:
- Apollo rate limiting (429 responses). The workflow backs off and retries with exponential delay rather than hammering the shared team key; a sustained 429 pauses the poll and alerts the admin.
- Duplicate Leads. Matching on normalized email and domain, plus Apollo's own person and organization IDs, keeps retries idempotent: a replayed workflow run checks SyncAttempt before writing again, so a network timeout that already succeeded on Salesforce's side doesn't create a second Lead.
- Missing required Salesforce fields. If a sandbox or production org requires a field Apollo didn't return (a specific industry code, for instance), the write fails cleanly, logs the Salesforce error in SyncAttempt, and routes to the SDR manager rather than retrying forever.
- Stale enrichment. An EnrichmentSnapshot older than a set window (say, 14 days) triggers a re-enrichment call before routing, since a prospect's title or company can change between the first Apollo pull and the eventual Salesforce write.
The agent must never invent a territory that isn't in the map, never override an explicit rule, and never write to Salesforce itself. Any of those is a hard stop to a person, not a judgment call for the model to work around.
A worked example with numbers
For example, imagine an SDR team configures the Lead Router to run hourly against a saved Apollo list of inbound signups and trial activations. Over one business day, Apollo returns 40 eligible people who match the list's qualifying criteria.
The workflow checks each one against LeadIntake and Salesforce for duplicates, dropping 4 that already exist as Leads or Contacts. Of the remaining 36, the territory map's explicit domain and region rules resolve 30 cleanly: a .com domain in a mapped U.S. state routes straight to the matching region's round-robin owner, each write logged as a RouteDecision with rule_version: 7 and a one-line rationale.
The remaining 6 go to the agent. Four are low match_confidence results Apollo could only partially resolve; two are companies with offices spanning two different mapped territories. The agent proposes a route and rationale for all 6, flags them for review, and stops. The SDR manager reviews the queue at the end of the day: approves 5, rejects 1 where the agent's proposed owner was already overloaded and manually reassigns it.
So of 40 raw Apollo matches: 4 duplicates skipped, 30 auto-routed without a person touching them, 6 reviewed by the manager in a single sitting instead of scattered through the day. Before this build, the manager reviewed roughly all 36 non-duplicate leads by hand; after, that drops to 6. These are illustrative counts for a sample day, not a measured result from a live deployment.
What to measure
- Eligible-to-created rate: the share of qualifying Apollo people that become a Salesforce Lead within the target window.
- Duplicate prevention rate: how many intake attempts match an existing record and get skipped instead of double-created.
- Routing override rate: how often the SDR manager rejects or changes an agent-proposed route, a signal the territory map needs updating.
- Enrichment match confidence distribution: the mix of
high,medium,low, andnoneresults coming back from Apollo, which tells you how much of the queue the agent will touch. - Time to owner assignment: elapsed time from Apollo enrichment to a Lead landing with an assigned owner in Salesforce.
- Error and retry rate: how often Salesforce writes fail on the first attempt, and why.
Builds like this are what a governed software factory produces: business teams describe what they need, and IT keeps SSO, permissions, credentials and audit under central control.
Frequently asked questions
How do I connect Apollo.io to Salesforce?
Apollo offers a native managed-package integration that syncs enriched fields into existing Salesforce records; see Apollo's setup guide. A custom routing workflow, like the one in this guide, is a separate build that sits alongside that native sync and adds territory logic Apollo doesn't provide.
Can Apollo automatically create leads in Salesforce?
Apollo's Salesforce integration can push and sync contact data under its configured sync settings; whether it creates new Leads outright depends on your package configuration. Check Apollo's sync behavior documentation for your specific setup before assuming either way.
How should Apollo leads be assigned to Salesforce territories?
Use an explicit, versioned territory map rather than letting a model guess. Store the rule version and a rationale with every routing decision, and send anything the map doesn't cover, like a low-confidence match or a multi-region company, to a person for review.
How do I prevent duplicate leads when syncing Apollo and Salesforce?
Match on Apollo's stable person and organization IDs plus a normalized email and domain, and check both your intake table and Salesforce before writing. Make retries idempotent so a replayed workflow run never creates a second Lead for the same person.
Does Apollo.io provide a public API for Salesforce integration?
Apollo provides a public People and Organizations API authenticated with an API key, separate from its packaged Salesforce sync. Salesforce itself exposes a standard REST API for creating and updating Leads; authentication and entitlement details vary by Apollo plan and Salesforce edition, so confirm both before building.
Before you go live
Run through this list with the SDR manager and whoever owns the Apollo and Salesforce credentials before the workflow goes live against production data. Most of these are one-time setup checks; the review queue and the territory map need an owner who checks in regularly, not just on launch day.
- [ ] Apollo API key stored in Major's central credential store, not in a workflow step or prompt
- [ ] Salesforce Connected App scoped to Lead read, create, and update only, tied to a dedicated integration user
- [ ] Territory map reviewed and versioned by the SDR manager before first production run
- [ ] Test run completed in a Salesforce sandbox with a duplicate, a clear match, and an ambiguous case
- [ ] Review queue approval step enabled for low-confidence matches and unmapped territories
- [ ] Retry and backoff logic confirmed against Apollo's documented rate limits
- [ ] Audit log checked for every RouteDecision and SyncAttempt row before go-live
- [ ] Owner named for monitoring the daily review queue and updating the territory map
More use cases by tool: More Apollo use cases, More Salesforce use cases.
More sales AI automation use cases
- AI agents for sales: every use case by tool
- Automate deal-risk alerts by combining HubSpot pipeline data with Gong call signals
- Automate stalled-cadence escalation between Salesloft activity and Salesforce opportunities
- Automate lead-to-sequence handoff between ZoomInfo enrichment and Outreach cadences
Start building on Major
Build a lead-intake app that holds enrichment history, applies approved territory rules, and sends uncertain routes to an SDR manager before Salesforce is updated.
Related articles
- Automate Jira-Intercom Bug Escalation With AI
- Automate Greenhouse-to-Workday New-Hire Handoffs
- Automate HubSpot GA4 Campaign Anomaly Briefs
About the author
Ritvij Gautam is Head of Growth at Major.
Last reviewed November 19, 2026 by Ritvij Gautam.
Frequently asked questions
- How do I connect Apollo.io to Salesforce?
- Apollo offers a native managed-package integration that syncs enriched fields into existing Salesforce records. A custom routing workflow is a separate build that sits alongside that native sync and adds territory logic Apollo doesn't provide.
- Can Apollo automatically create leads in Salesforce?
- Apollo's Salesforce integration can push and sync contact data under its configured sync settings; whether it creates new Leads outright depends on your package configuration. Check Apollo's sync behavior documentation for your specific setup before assuming either way.
- How should Apollo leads be assigned to Salesforce territories?
- Use an explicit, versioned territory map rather than letting a model guess. Store the rule version and a rationale with every routing decision, and send anything the map doesn't cover, like a low-confidence match or a multi-region company, to a person for review.
- How do I prevent duplicate leads when syncing Apollo and Salesforce?
- Match on Apollo's stable person and organization IDs plus a normalized email and domain, and check both your intake table and Salesforce before writing. Make retries idempotent so a replayed workflow run never creates a second Lead for the same person.
- Does Apollo.io provide a public API for Salesforce integration?
- Apollo provides a public People and Organizations API authenticated with an API key, separate from its packaged Salesforce sync. Salesforce itself exposes a standard REST API for creating and updating Leads; authentication and entitlement details vary by Apollo plan and Salesforce edition, so confirm both before building.