What happens if a webhook never arrives?

A timeout closes the record with whatever sources reported, and flags it as incomplete instead of waiting forever.

What happens if two sources disagree?

The conflict gets flagged rather than silently resolved by picking one source over the other.

Can I add a fourth webhook source later?

Yes, new sources plug into the same entry point and matching key, no need to rebuild the reconciliation logic.

How is this different from writing my own matching logic?

Most custom logic assumes webhooks arrive in order. This workflow does not make that assumption, so a late or out-of-order webhook cannot silently corrupt a record.

Webhook Event Reconciliation

When Stripe and Shopify disagree, you should not find out from a customer complaint.

Unmeshed catches every webhook about the same event, from Stripe, Shopify, or any internal system, and merges them into one clean, reliable record. No more custom matching logic that breaks the moment a payload changes shape.

Map My Workflow Talk to Us

Handles out-of-order deliveryDeduplicates by designFree tier available

Trusted by teams at leading organisations

What Changes

Three systems all have an opinion about the same event. Only one of them should win.

Before

Each webhook source gets its own handler, with its own half-built matching logic

A late or out-of-order webhook can overwrite a correct record with a stale one

Nobody notices when Stripe and Shopify disagree until a customer complains

Debugging means pulling logs from three different systems and manually lining up timestamps

After

Every webhook about the same event routes into one reconciliation workflow

Events are matched by a stable key, not by arrival order, so a late webhook cannot corrupt the record

A mismatch between sources gets flagged instead of silently picking whichever webhook happened to land first

One reconciled record shows exactly which source said what, and when

Intake

Every Source Lands in One Place

Stripe, Shopify, and any internal system all send their webhooks to the same entry point. Each payload gets normalized into a common shape before anything else happens, so downstream logic does not need to know which source it came from.

RULE
Accept webhooks from every source at one endpoint
RULE
Normalize each payload into a common event shape
RULE
Extract the stable key that identifies the underlying event, not the webhook itself

Intake Path

Stripe

webhook fired

Shopify

webhook fired

Internal

webhook fired

One Entry Point

# accept_webhook

Normalized, Key Extracted

Matching Path

Look Up Stable Key

not the webhook itself

Attach to Event

key already in progress

New Partial Record

first witness for this key

Hold Open Until Complete

all sources reported, or timeout

Matching

Group by the Real Event, Not the Webhook

A webhook is not an event. Three webhooks about the same order are one event with three witnesses. This step groups incoming webhooks by that shared key so they can be reconciled together instead of processed as three unrelated updates.

RULE
Look up whether this key already has a partial record in progress
RULE
Attach the new webhook to the existing event instead of creating a duplicate
RULE
Hold the record open until every expected source has reported in, or a timeout passes

Reconciliation

Merge Without Guessing

Once enough sources have reported, a rule merges them into a single record. If two sources disagree on something that matters, that gets flagged instead of silently resolved by whichever webhook arrived first.

RULE
Merge fields from every source into one clean record
RULE
Flag conflicting values instead of picking one arbitrarily
RULE
The same merge logic runs the same way for every event

Reconciliation Path

Merge Rule Runs

same logic, every event

Fields Agree

merged, no dispute

Fields Conflict

flagged, not guessed

One Merged Record

conflicts attached, not hidden

Finalize Path

Write Final Record

# write_record, once

Attach Raw Sources

full trail, kept for later

Event Complete

Finalize

One Record, Fully Traceable

The finished record is written once, with a full trail of which source contributed which field and when it arrived. If something needs debugging later, the answer is in one place, not three.

RULE
Write the final reconciled record once
RULE
Keep the raw source data attached for traceability
RULE
Mark the event complete once reconciliation finishes

What this template is built to do

A webhook is not an event. Three webhooks about the same order are one event with three witnesses, reconciled into one record instead of three competing updates.

One entry point for every webhook source.

Stable key matching, not arrival order.

Full trail of which source said what, and when.

Connects to your stack

Catches webhooks from anywhere you already send them.

StripeShopifyAny REST webhook

Python

JavaScript

Go+100 more

Inside the workflow

Four pieces, one workflow.

One entry point

Every webhook source lands in the same place, normalized before anything else happens.

Key-based matching

Events are grouped by what actually happened, not by which webhook arrived first.

Conflict flagging

Disagreeing sources get surfaced, not silently resolved.

Full traceability

One reconciled record shows exactly which source contributed what.

Why it holds up in production

Built for the order that does not arrive in order.

Out-of-order safe

A late webhook cannot overwrite a correct record.

No duplicate records

Matching happens by key, not by first arrival.

Conflicts surfaced, not hidden

Disagreeing sources get flagged instead of silently merged.

Full run history

Every source's contribution to a record is logged and readable.

Frequently asked questions

Still have questions? Talk to us.

Stop guessing which webhook is telling the truth.

Connect Stripe, Shopify, or any internal system, and every event gets reconciled into one clean record automatically.

Map My Workflow Talk to Us