If you’re trying to get your product analytics out of a silo and line them up with your sales pipeline, you’re not alone. Lots of teams want to see how user behavior in their app connects to actual sales and customer status. That means getting Amplitude and Salesforce talking to each other. Sounds simple, right? Well, there’s a bit more to it. This guide walks you through the real steps, the gotchas, and what’s actually worth your time.
Why bother connecting Amplitude and Salesforce?
Here’s the deal: Amplitude is great for tracking what people do in your product—clicks, feature use, churn, all that. Salesforce is where you keep your customer accounts, sales progress, and revenue info. If you connect the two, you can:
- See which product actions lead to sales (and which don’t).
- Give your sales team insight into what users are doing, in real time.
- Tie product metrics directly to revenue (no more guessing).
- Trigger sales workflows based on real product usage.
But you don’t need a perfect, end-to-end integration to get value. Even a simple sync can go a long way.
How to connect Amplitude with Salesforce: Step-by-step
There’s no official, out-of-the-box Amplitude-to-Salesforce integration—at least not as of 2024. You have three main paths:
- Use a third-party integration tool (like Zapier, Tray.io, or Workato)
- Build a custom integration using APIs
- Export/import CSVs the old-fashioned way
I’ll walk you through each, with honest notes about what works and what’s a pain.
Step 1: Get clear on what data you actually need
Before you start wiring things up, figure out why you want the integration. Ask yourself:
- Which Amplitude events or properties do you want in Salesforce? (e.g., “User signed up,” “Feature X used 5 times”)
- Do you need Salesforce data in Amplitude, Amplitude data in Salesforce, or both?
- How often does the data need to sync? (Real-time? Daily? Weekly?)
Pro tip: Don’t try to sync everything. Focus on a few high-value signals to start, or you’ll drown in data and permissions headaches.
Step 2: Choose your integration approach
Option A: Third-party integration tools
This is usually the fastest way if you want to avoid custom code. You’ll need accounts on both ends, and sometimes a paid plan for the integration tool.
Popular options:
- Zapier: Good for simple, event-based triggers. Limited by what you can pull from Amplitude (it’s mostly “new cohort member” or “event occurs”).
- Tray.io & Workato: More powerful, but pricier. They can handle multi-step workflows, richer data mapping, and bulk updates.
How it works:
- Set a trigger in Amplitude (like a new event, or a user enters a cohort).
- Pass data to Salesforce as a new Lead, Contact, or custom object, or update an existing record.
- Map fields between the two systems.
What’s good: - Fast to set up, no engineering required. - Decent for proof-of-concept or small teams.
What’s not: - Can get expensive fast as data volume grows. - Limited by what Amplitude exposes through its APIs. - “No-code” = “limited flexibility.” If you want complex logic, you’ll hit a wall.
Ignore if: You need to move large amounts of data, or want to customize the integration heavily.
Option B: Custom integration via APIs
If you want full control, or have specific needs, you’ll end up here. Both Amplitude and Salesforce have APIs—it’s just a matter of wiring them up.
High-level plan:
- Decide on your sync direction (Amplitude -> Salesforce, Salesforce -> Amplitude, or both).
- Use the Amplitude Export API or Webhooks to pull the data you need.
- Use the Salesforce REST API to create or update records.
- Host your integration somewhere (AWS Lambda, Heroku, whatever your stack likes).
- Set up authentication for both APIs. (This is the part where most folks get bogged down.)
What’s good: - Total flexibility—map whatever you want, however you want. - Automate bulk syncs or real-time updates.
What’s not: - Takes real engineering time to build and maintain. - You’re on the hook for handling API changes, failures, and Salesforce’s strict API limits. - Security and permissions can be a pain.
Ignore if: You just want to test an idea or only need a few fields synced.
Option C: Manual CSV Export/Import
Honestly, for one-off projects or small teams, this is sometimes all you need.
How it works:
- Export users and events from Amplitude as CSV.
- Clean up the data (match on email, user ID, etc.).
- Import into Salesforce using Data Loader or the Import Wizard.
What’s good: - No setup, no cost, no code. - Great for historical analysis or quarterly reviews.
What’s not: - Not automated. Takes time and is error-prone. - Not viable for real-time insights.
Ignore if: You want regular, automated updates.
Step 3: Set up your integration (with honest, practical steps)
If you’re using Zapier (example: Amplitude -> Salesforce Contact update):
- Create a Zap.
- Trigger: “New Cohort Member in Amplitude” (or similar).
- Action: “Update Contact in Salesforce.”
- Connect your accounts.
- You’ll need API keys or OAuth logins for both.
- Map the fields.
- E.g., Amplitude “user_id” -> Salesforce “Email.”
- Only map what you actually need.
- Test it.
- Use test data; check for duplicates.
- Watch out for Salesforce field mismatches—names must match exactly.
- Turn it on.
- Monitor for the first week—Zapier errors can be cryptic.
Honest take: Zapier’s Amplitude triggers are limited. If you want to sync more than simple events or cohorts, look at Tray.io or go custom.
If you’re building a custom integration (Amplitude Export API -> Salesforce REST API):
- Get API credentials for both platforms.
- Amplitude: Go to Settings > Projects > API Keys.
- Salesforce: Set up a Connected App and get your client ID/secret.
- Write a script (Python is common).
- Use Amplitude’s Export API to pull the events/users you care about.
- Transform data as needed (matching fields, formatting dates, etc.).
- Use Salesforce’s REST API to upsert records.
- Handle errors and rate limits.
- Both APIs have strict limits. Build in retries and error logging.
- Automate the script.
- Schedule with cron, AWS Lambda, or your favorite scheduler.
- Secure your secrets.
- Don’t hardcode credentials. Use environment variables or a secrets manager.
- Test with sandbox data.
- Don’t blast your production Salesforce with junk data.
Honest take: This is the only way to get exactly what you want, but expect to spend a week (or more) on setup and testing. Maintenance is real—APIs change, and Salesforce’s limits are strict.
If you’re doing CSV exports/imports:
- Export from Amplitude.
- Go to the Users or Events tab > Export as CSV.
- Clean the data.
- Remove duplicate rows, fix headers, and ensure columns match Salesforce fields.
- Import to Salesforce.
- Use Data Loader or Import Wizard.
- Map fields carefully (Salesforce will reject mismatches).
- Spot check the import.
- Check for errors, missing data, or unexpected duplicates.
Honest take: Don’t make this a habit for anything ongoing. But for a quick snapshot, it works.
Step 4: Validate and monitor your integration
- Run a test. Start with a small batch of data.
- Check both sides. Make sure data lands where you expect in Salesforce.
- Set up alerts. For failures, duplicates, or sync errors.
- Review regularly. Data models change. Don’t set and forget.
Common pitfalls (and how to dodge them)
- User IDs don’t match. Amplitude and Salesforce often use different identifiers. Always pick a reliable join key (email is common, but beware of duplicates).
- API limits. Both platforms throttle you. If you’re moving lots of data, watch your quotas.
- Field mismatches. Salesforce is picky. If a field isn’t mapped just right, your sync will fail.
- Too much data. Start simple. Syncing every event is usually overkill and eats up API calls.
- Maintenance. Someone needs to own this integration. Document what you’ve built.
What to ignore (for now)
- “360-degree view” dashboards. Don’t get lost chasing perfect dashboards. Prove the basics work first.
- Real-time everything. Most teams don’t need second-by-second sync. Hourly or daily works for almost everyone.
- All the possible fields. You can always add more later. Start with what matters most.
Wrapping up
Connecting Amplitude and Salesforce isn’t magic, but it’s doable—and worth it if you want to tie product usage to sales outcomes. Start small, pick the approach that fits your team, and don’t overcomplicate things. Most of the value comes from a handful of key signals, not syncing everything under the sun. Set it up, see what works, then iterate. Simple wins.