Connecting Salesforce to a payment processor like Stripe is one of the most common integration tasks in Revenue Cloud work — and one of the most intimidating for beginners, because money is involved and mistakes are visible. But the flow itself is completely logical. Once you can picture it end to end, the fear goes away and the care stays — which is exactly the balance you want when handling payments.
If you’re brand new to integration concepts, read Salesforce Integration for Beginners first; this post follows one real connection through.
Why these two systems talk
Salesforce knows what the customer owes — the quote, the contract, the invoice from the Quote-to-Cash journey. But Salesforce isn’t a bank. Stripe is the specialist that actually moves money: securely capturing card details, charging cards, handling refunds, and dealing with the messy world of banks and fraud.
So the division of labor is clean: Salesforce owns the what and why; Stripe owns the moving the money. Integration is how they coordinate.
The flow, step by step
Picture a customer paying an invoice. Here’s the conversation between the two systems:
1. Salesforce asks Stripe to set up a payment (outbound)
When it’s time to collect, Salesforce calls Stripe’s API: “Create a payment for €500 for this customer.” This is an outbound call — Salesforce reaching out and ordering from Stripe’s menu.
2. Stripe handles the sensitive part
The actual card number is captured by Stripe, not stored in Salesforce. This matters enormously: keeping raw card data out of your own systems is central to security and compliance (PCI). Stripe gives you back a safe reference — a token — instead of the real card number. A beginner rule that will never steer you wrong: never store raw card numbers in Salesforce. Let Stripe hold them and hand you a token.
3. Stripe processes and responds
Stripe talks to the banks, charges the card, and returns a result: success or failure, plus a payment ID.
4. Stripe tells Salesforce what happened (inbound)
Here’s the part beginners miss. The payment might complete after the initial request — a bank delay, an extra verification. So Stripe sends an inbound message back to Salesforce, called a webhook: “Payment pi_123 succeeded.” Salesforce receives it and updates the invoice to Paid.
A webhook is just the other system knocking on your door to tell you something happened, instead of you constantly asking “is it done yet?” It’s the inbound half of the conversation, and it’s how the two systems stay in sync over time.
The idea that protects you: idempotency
This is the single most important concept in payment integration, and it has an intimidating name for a simple idea. Idempotency means: doing the same operation twice has the same effect as doing it once.
Why does this matter? Networks are unreliable. Imagine Salesforce sends “charge €500,” but the response gets lost on the way back. Salesforce doesn’t know if it worked, so it retries — and now you’ve charged the customer twice. That’s a real, expensive, trust-destroying mistake.
The fix: send an idempotency key — a unique ID — with the charge request. If Stripe sees the same key twice, it knows it’s the same charge and refuses to double it. Retry as many times as you like; the customer is charged exactly once.
If you remember one thing about payment integration, remember this: every charge request carries a unique key so that retries are safe. This single idea is what lets you handle network failures without ever double-charging a human being.
Why the careful mindset is the whole job
A beginner writes the happy path: ask Stripe to charge, mark it paid, done. A professional asks the uncomfortable questions:
- What if Stripe is down when we try to charge?
- What if the charge succeeds but the webhook telling us never arrives?
- What if the customer’s card is declined — what does the invoice show, and what does the customer see?
Handling these gracefully is the work. Money integration is unforgiving precisely because customers feel every error immediately. I treat each step as a decision I have to justify, because “the system charged me twice” is the kind of failure that loses a customer forever. That carefulness isn’t slowness — it’s professionalism.
Your next step
You’ve now followed a complete two-way integration with the one safety idea that makes it trustworthy. The same patterns — outbound requests, inbound webhooks, careful failure handling — apply to every integration you’ll build. See them again in a different shape with DocuSign + Salesforce, where the “money” becomes “a signature.” Keep building through the Integration category.