Stripe Make.com Integration: Building a Webhook Reconciliation Ledger
Affiliate Disclosure: We review products independently. When you buy through our links, we may earn a commission or a compound recurring commission at zero extra cost to you. Read our editorial policy.
A Stripe Make.com integration can automate payment notifications, transaction logging, and reconciliation workflows. The challenge is ensuring that every event is recorded correctly, duplicate deliveries do not create duplicate financial entries, and payout totals can be traced back to the transactions that produced them.
A basic automation might receive a Stripe event and append a row to a spreadsheet. That is useful for visibility, but it is not sufficient as a financial reconciliation system. Stripe can retry webhook deliveries, and events may arrive in an order that differs from the sequence your workflow expects. A payout can also reflect multiple balance transactions, including charges, fees, refunds, and adjustments. The exact records included depend on the account activity and payout being reconciled.
A more dependable design separates three responsibilities:
- Event capture: Record that Stripe sent an event.
- Transaction processing: Update the appropriate payment or transaction record without duplicating it.
- Reconciliation: Compare expected transaction amounts with Stripe’s payout records and the corresponding bank deposit.
This guide explains how to structure that workflow using Stripe webhooks, Make.com, and a persistent ledger. The examples describe an implementation pattern, not a claim that a specific scenario has been tested in a live Stripe or Make.com account.
What a Stripe Reconciliation Ledger Should Track
A reconciliation ledger is a structured record of payment activity and its processing status. It should make it possible to trace a transaction from the original Stripe event through the associated balance transaction and, where applicable, the payout and bank deposit.
Do not use a single spreadsheet row as a substitute for every object in Stripe. A payment, a Stripe event, a balance transaction, and a payout represent different things.
Recommended ledger structure
| Field | Purpose |
|---|---|
stripe_event_id | Identifies the Stripe event and helps detect duplicate event deliveries |
event_type | Records the event type, such as a payment-related event or payout update |
stripe_object_id | Identifies the relevant Stripe object, where applicable |
payment_intent_id | Links a payment flow to its PaymentIntent, when relevant |
charge_id | Identifies a charge, when relevant |
balance_transaction_id | Identifies the balance transaction used for financial reporting |
payout_id | Links a balance transaction to a payout when that relationship applies |
amount | Records the amount in the original currency and unit used by Stripe |
currency | Identifies the currency for the amount |
event_created_at | Records the event timestamp supplied by Stripe |
received_at | Records when the automation received the event |
processing_status | Tracks whether the event is received, processed, failed, or awaiting review |
reconciliation_status | Tracks whether the financial record has been matched or needs investigation |
last_error | Stores a concise explanation when processing fails |
Not every field is available in every Stripe event. Some values must be retrieved from the relevant Stripe API resource, and some relationships only become clear after a payout is created.
Store identifiers and amounts in their appropriate data types. Preserve the original currency, and do not assume all transactions are denominated in the same currency.
How the Integration Works
A reliable design separates incoming events from financial reconciliation.
The following is the logical workflow:
- Stripe sends a webhook event to a Make.com custom webhook or a suitable Stripe trigger.
- Make.com captures the event and records its event ID.
- The scenario checks whether that event has already been processed.
- The workflow validates the event type and extracts the relevant object identifiers.
- It retrieves additional Stripe data when the event payload does not contain everything needed.
- The workflow writes or updates the corresponding ledger records.
- A separate reconciliation step matches balance transactions to Stripe payouts and, where available, bank deposit records.
- Exceptions are flagged for review instead of being silently marked as reconciled.
Stripe’s webhook documentation explains how events are delivered to configured endpoints. Make.com’s webhook documentation explains how incoming webhook requests trigger scenarios and how queued requests are handled.
Why event capture and reconciliation should be separate
A webhook confirms that Stripe has reported an event. It does not automatically prove that the transaction has reached the bank, that the payout has been reconciled, or that the corresponding ledger entry is correct.
For example, a successful payment may be recorded before the related funds are included in a payout. The payout may then contain several transactions, fees, refunds, or adjustments.
The event ledger should therefore record what happened at the event level. A separate reconciliation process should establish how those events relate to Stripe’s financial records.
Step 1: Create a Persistent Ledger
Choose a data store that supports durable records, unique identifiers, and reliable updates. A spreadsheet may be adequate for a small, low-volume workflow, but a database is generally easier to manage when you need stronger uniqueness constraints, concurrent processing, audit history, and larger volumes.
A useful design separates event records from financial transaction records.
Event table
Store one record per Stripe event ID. Include the event type, Stripe object ID, received timestamp, processing status, and any processing error.
Financial transaction table
Store the relevant Stripe balance transaction or other financial record, including the amount, currency, fee, net amount, transaction type, and related payout ID where applicable.
Payout table
Store payout-level details, such as the Stripe payout ID, expected amount, currency, payout status, and reconciliation status.
These records should be connected through stable Stripe identifiers, not by matching amounts alone.
Two transactions can have the same amount. A refund can offset a charge, and a payout can contain many individual balance transactions. Amount-only matching is not sufficient to establish a reliable relationship.
Step 2: Configure Stripe Webhook Delivery
In Stripe, create or select a webhook endpoint and subscribe only to the event types needed by your workflow.
The correct event list depends on what the ledger is intended to track. A payment-status ledger may need payment-related events, while a payout reconciliation workflow also needs access to payout and balance transaction information.
Do not subscribe to every available event simply because it is possible. Extra events increase processing volume and make it harder to distinguish important financial changes from unrelated activity.
Choose the appropriate integration method
You can use a Stripe integration or trigger in Make.com when it supports the event and behavior you need. A custom webhook can be useful when you need to receive a specific event payload or connect a service that is not covered by the available app modules.
Check the current Make.com module documentation before choosing. Module availability and behavior can change.
If you configure a custom webhook, secure it using the authentication options available in Make.com where appropriate. Never publish secret keys or sensitive webhook credentials in a public URL, article screenshot, or shared scenario.
For Stripe’s signature verification requirements and delivery behavior, follow the official Stripe webhook documentation.
Capture the event ID
Each Stripe event has an event identifier. Store it before processing the financial operation so that repeated delivery of the same event can be recognized.
A simplified event record might look like this:
{
"stripe_event_id": "evt_example",
"event_type": "payment_intent.succeeded",
"stripe_object_id": "pi_example",
"processing_status": "received"
}These identifiers are placeholders, not real Stripe objects. The actual fields available depend on the event received.
Step 3: Prevent Duplicate Processing
Stripe can retry webhook deliveries when an endpoint does not acknowledge receipt successfully. As a result, the same event may reach your integration more than once.
Your workflow must distinguish a repeated delivery of the same event from a genuinely new event.
Use the event ID as a deduplication key
Before performing an operation that creates or changes a financial record, check whether the event ID already exists in the event ledger.
A safe logical sequence is:
- Receive the event.
- Look up its event ID in the ledger.
- If it has already been processed successfully, avoid repeating the same side effect.
- If it is new, create a durable record and process it.
- Record the outcome, including any failure that requires a retry or investigation.
A simple lookup followed by a write may still allow duplicate processing if two scenario executions run simultaneously. Where possible, enforce uniqueness in the database or use an atomic insert-or-update operation.
Event deduplication is not the same as business-operation idempotency
The same event can be delivered repeatedly, but separate Stripe events can also refer to the same underlying business object.
For that reason, event ID deduplication alone may not protect every downstream operation. Your ledger should also identify the financial object being updated and define which state transitions are valid.
For example, a workflow should not create a second revenue entry merely because it receives a different event concerning an object that has already been recorded.
If your scenario makes write requests to Stripe, use Stripe’s supported idempotency mechanism for applicable API operations. That mechanism is distinct from deduplicating incoming webhook events.
Step 4: Design Error Handling in Make.com
A reconciliation ledger is only useful if failures are visible and recoverable.
An error can occur when Make.com cannot reach a module, an API request fails, a field is missing, or a downstream destination is unavailable. Your workflow should record enough information to identify the failed event and retry it safely.
Separate transient failures from data problems
Transient failures include temporary service interruptions, timeouts, and rate limits. These may be suitable for controlled retries.
Data problems include missing identifiers, unsupported event types, unexpected currencies, and records that cannot be matched. Repeating the same request without changing the underlying data is unlikely to solve these problems.
Use separate handling paths for these cases. A transient failure can be retried according to a defined policy. A data problem should be recorded for review rather than repeatedly processed without a resolution.
Avoid acknowledging success before durable capture
Stripe expects a successful HTTP response to indicate that an event has been received. If the downstream workflow takes too long or fails after receipt, the behavior of the webhook response becomes important.
Make.com’s webhook response behavior depends on the scenario configuration and where the Webhook response module is placed. The Make.com webhook documentation describes the available responses and queue behavior.
Do not assume that returning a successful response means every later module has completed correctly. If the webhook endpoint returns a successful response before downstream processing finishes, first confirm that the event has been durably stored. The workflow should track the event’s processing status separately and provide a controlled way to retry failures. If the event has not been safely captured, do not treat a successful response as proof that it can be recovered later.
For more detail on this class of failure, see TSA’s guide to handling Make.com webhook timeouts without losing lead data. The same design principle applies to financial workflows: an acknowledged request and a completed business operation are different states.
Step 5: Match Balance Transactions to Payouts
This is the core of financial reconciliation.
A Stripe payment event and a bank deposit are not interchangeable records. To reconcile a payout, use Stripe’s financial records to identify which balance transactions contributed to the payout.
Stripe provides a payout reconciliation report for automatic payouts. Its documentation also explains how to identify the balance transactions associated with a payout using the Dashboard or API.
Use the payout ID to establish the relationship
For automatic payouts, Stripe’s payout reconciliation guidance describes the available methods for finding the balance transactions included in or affecting a payout.
Where appropriate, retrieve balance transactions using the payout identifier and the relevant Stripe API resource. Store the resulting transaction IDs and payout ID in your ledger.
Do not infer the relationship solely from a matching net amount. Several different combinations of charges, refunds, fees, and adjustments can produce the same total.
Calculate the expected payout amount
For the balance transactions included in a payout, calculate the expected net amount using the appropriate signed amounts and currency.
A simplified illustration:
| Component | Amount |
|---|---|
| Charge A, net of applicable fee | $96.00 |
| Charge B, net of applicable fee | $48.00 |
| Refund | -$20.00 |
| Other adjustment | -$4.00 |
| Expected payout total | $120.00 |
These values are illustrative. Actual Stripe balance transaction fields and sign conventions should be taken from the returned records and current documentation.
The example shows why a payout total may not equal the sum of the original charge amounts. Fees, refunds, and adjustments can change the net amount.
Account for payout timing
A transaction does not necessarily appear in a payout immediately after a payment event occurs. Availability, payout schedules, account settings, and other activity can affect when funds are included.
For automatic payouts, Stripe provides reconciliation information that can be used to identify the associated balance transactions. The relevant records may not be available for reconciliation immediately, so check the payout’s status and the availability of its associated balance transactions before treating an unmatched transaction as an error. See Stripe’s current payout reconciliation documentation for the applicable process.
For that reason, a ledger should be able to represent a transaction as awaiting payout reconciliation. It should not classify every unmatched transaction as an error simply because the expected payout has not yet been created.
Step 6: Flag Discrepancies Instead of Hiding Them
A reconciliation workflow should make unresolved differences easy to find.
Useful exception categories include:
- A Stripe event was received but the ledger update failed.
- A financial transaction has no expected payout relationship yet.
- A payout’s expected total differs from the observed payout amount.
- A transaction appears more than once in the downstream ledger.
- A currency or amount field is missing or inconsistent.
- A payout has not reached the expected status.
- The bank deposit cannot yet be matched to a Stripe payout.
Each exception should include the relevant Stripe IDs, the observed values, the expected values if known, the time of the last attempt, and a concise reason for the mismatch.
Avoid silently overwriting an earlier financial record. Prefer an auditable update that preserves the previous state and explains why it changed.
A useful exception record
{
"payout_id": "po_example",
"expected_amount": 12000,
"currency": "usd",
"reconciliation_status": "needs_review",
"exception_reason": "bank_deposit_not_matched"
}This is a simplified illustrative record. The amount uses a placeholder value and should be represented according to the currency’s supported minor-unit conventions and the schema chosen for your ledger.
A real implementation should also record the observed amount, relevant timestamps, and the identifiers needed to investigate the discrepancy.
Step 7: Test the Workflow Before Relying on It
Before using the integration for financial reporting, test the cases that are most likely to cause missing or duplicated records.
Use Stripe’s test environment and test events where available. Keep test data separate from live financial records.
At minimum, validate the following scenarios:
| Test case | Expected behavior |
|---|---|
| A new supported event arrives | One event record is created and processed |
| The same event is delivered again | The existing event is recognized and duplicate side effects are avoided |
| A downstream module fails | The failure is visible and the event can be safely retried |
| An event contains an unexpected field or object | The workflow flags or handles it without inventing missing data |
| A payout includes multiple transactions | Each relevant balance transaction can be traced to the payout |
| A payout has not yet been created | The workflow keeps the transaction pending rather than falsely flagging a mismatch |
| A refund or adjustment affects the payout | The reconciliation calculation accounts for the relevant balance transaction |
| A bank deposit does not match the expected payout | The exception is recorded for investigation |
Do not claim the scenario is production-ready until these cases have been tested against the actual configuration, including the destination database or spreadsheet and the relevant Stripe account settings.
Common Mistakes to Avoid
Treating every webhook as a payment
Stripe emits events for many object types and lifecycle changes. Filter for the events your workflow actually needs and handle each type according to its meaning.
Using amounts as unique identifiers
Two transactions can have the same amount. Use Stripe identifiers to establish relationships, then use amounts and currencies as reconciliation checks.
Assuming one event equals one financial transaction
An event describes a change or occurrence. The financial records needed for reconciliation may be separate Stripe objects and may require an API lookup.
Marking a payout as reconciled too early
A payment event does not prove that the funds have been paid out or matched to a bank deposit. Track the payout and reconciliation states separately.
Retrying every failure indefinitely
Some errors are temporary; others require data correction or configuration changes. Use bounded retries and make persistent failures visible.
Overwriting the audit trail
If an amount or status changes, preserve the previous record or change history. An audit trail is essential when investigating discrepancies later.
Frequently Asked Questions
Can Make.com receive Stripe webhooks?
Make.com supports custom webhooks and app-specific instant triggers. The correct option depends on the event and the current modules available for your integration. Review the Make.com webhook documentation before choosing the setup.
How do I prevent duplicate Stripe records in Make.com?
Use the Stripe event ID as a deduplication key and check whether it has already been processed before creating downstream records. Where possible, enforce uniqueness atomically in the destination database and protect business operations against duplicate side effects.
Does a successful Stripe webhook mean the payment has reached my bank?
No. A webhook reports an event. Payout timing and reconciliation are separate concerns. Use Stripe’s payout and balance transaction records to trace the financial activity and match it to the relevant payout.
How do I match Stripe transactions to a payout?
For automatic payouts, use Stripe’s payout reconciliation report, Dashboard, or relevant API resources to identify the balance transactions included in the payout. Match using Stripe identifiers and verify amounts and currency rather than relying on the total alone.
What should happen when a Make.com scenario fails after receiving a webhook?
The event should remain traceable, and the workflow should have a safe way to retry the failed processing. If the webhook has already been acknowledged, do not rely on Stripe to redeliver it automatically as the only recovery mechanism. Record the processing state and provide a controlled retry path.
Is a spreadsheet sufficient for a Stripe reconciliation ledger?
A spreadsheet can be useful for a small workflow or reporting view, but it may not provide the uniqueness constraints, concurrent update protection, and audit history required for a larger financial workflow. Choose storage based on transaction volume, recovery requirements, and the consequences of duplicate or missing records.
Conclusion
A Stripe Make.com integration can improve payment visibility, but reliable reconciliation requires more than sending webhook data into a spreadsheet.
Capture events durably, deduplicate deliveries, distinguish event records from financial transactions, and use Stripe’s payout and balance transaction data to establish the actual financial relationships. Keep unresolved differences visible and make failed processing safe to retry.
The goal is a ledger that records which events were received and processed, which financial transactions have been matched to payouts, and which discrepancies remain unresolved. A successful event-processing run alone does not establish that a payout has been reconciled or that the corresponding bank deposit has been verified.
