DEV Community

Sithija Kalhara
Sithija Kalhara

Posted on

Stripe Webhooks Were Double-Crediting My Users — Fixed with One Atomic MongoDB Query

I was building the coin system for Eyerone, a social platform with live streaming and virtual gifts: users buy a coin pack through Stripe Checkout, Stripe calls my webhook, and my server credits the coins.

It worked perfectly in testing. Then I noticed something in the database: some users had been credited twice for a single payment.

No hacking, no bugs in Stripe. Just a classic race condition in my own code. Here's what happened and the fix.

The naive version

This is roughly what my fulfillment logic looked like:

async function fulfillOrder(sessionId) {
  const order = await Order.findOne({ stripeSessionId: sessionId });

  if (order.status === 'paid') return; // already handled ✅ ...right?

  order.status = 'paid';
  await order.save();

  await User.updateOne(
    { _id: order.userId },
    { $inc: { coins: order.coins } }
  );
}
Enter fullscreen mode Exit fullscreen mode

Looks safe. We check the status before doing anything. So how did coins get credited twice?

Why it breaks

Two things are true in production:

  1. Stripe can deliver the same event more than once. Retries after a slow response, network hiccups, or manual resends from the dashboard all mean your endpoint must handle duplicates.
  2. Your success page might also try to fulfill. Mine did — the redirect page verified the session and called fulfillOrder too, as a fallback in case the webhook was slow.

So two requests can arrive at almost the same time:

Request A: findOne → status = 'pending'
Request B: findOne → status = 'pending'   ← A hasn't saved yet
Request A: save 'paid', $inc coins
Request B: save 'paid', $inc coins        ← double credit 💸
Enter fullscreen mode Exit fullscreen mode

The problem is the gap between reading the status and writing it. Any check-then-update done in two separate queries has this gap.

The fix: make the check and the update one operation

MongoDB's findOneAndUpdate matches and modifies a document atomically. If we put the status condition inside the filter, only one request can ever win:

async function fulfillOrder(sessionId) {
  const order = await Order.findOneAndUpdate(
    { stripeSessionId: sessionId, status: 'pending' }, // only match if still pending
    { $set: { status: 'paid', paidAt: new Date() } },
    { new: true }
  );

  // Someone else already flipped it to 'paid' — nothing to do
  if (!order) return { alreadyProcessed: true };

  await User.updateOne(
    { _id: order.userId },
    { $inc: { coins: order.coins } }
  );

  return { alreadyProcessed: false };
}
Enter fullscreen mode Exit fullscreen mode

Now the race plays out like this:

Request A: findOneAndUpdate(status: 'pending') → matches, sets 'paid'
Request B: findOneAndUpdate(status: 'pending') → no match → returns null → exits
Enter fullscreen mode Exit fullscreen mode

Exactly one credit, no matter how many times the webhook fires.

Going one step further: a transaction

There's still one small gap: if the server crashes after marking the order paid but before crediting coins, the user paid and got nothing. Wrapping both writes in a transaction closes that:

import mongoose from 'mongoose';

async function fulfillOrder(sessionId) {
  const session = await mongoose.startSession();
  let result = { alreadyProcessed: true };

  try {
    await session.withTransaction(async () => {
      const order = await Order.findOneAndUpdate(
        { stripeSessionId: sessionId, status: 'pending' },
        { $set: { status: 'paid', paidAt: new Date() } },
        { new: true, session }
      );

      if (!order) return;

      await User.updateOne(
        { _id: order.userId },
        { $inc: { coins: order.coins } },
        { session }
      );

      result = { alreadyProcessed: false };
    });
  } finally {
    await session.endSession();
  }

  return result;
}
Enter fullscreen mode Exit fullscreen mode

Either both writes happen or neither does. (Transactions need a replica set — MongoDB Atlas clusters have this by default.)

Don't forget the webhook basics

The atomic update protects your data, but the endpoint itself also needs to be set up correctly:

import express from 'express';
import Stripe from 'stripe';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);
const router = express.Router();

// Raw body is required for signature verification
router.post(
  '/stripe/webhook',
  express.raw({ type: 'application/json' }),
  async (req, res) => {
    let event;

    try {
      event = stripe.webhooks.constructEvent(
        req.body,
        req.headers['stripe-signature'],
        process.env.STRIPE_WEBHOOK_SECRET
      );
    } catch (err) {
      return res.status(400).send(`Webhook Error: ${err.message}`);
    }

    if (event.type === 'checkout.session.completed') {
      await fulfillOrder(event.data.object.id);
    }

    res.json({ received: true });
  }
);

export default router;
Enter fullscreen mode Exit fullscreen mode

Three things that tripped me up:

  • Mount the webhook route before app.use(express.json()). If the JSON parser runs first, the raw body is gone and signature verification always fails.
  • Always verify the signature. Without it, anyone can POST a fake "payment succeeded" event to your endpoint.
  • Respond fast. Do the minimum work and return 200. Slow responses cause Stripe to retry — which is exactly how duplicates show up.

Bonus: a unique index as a safety net

Add a unique index on the Stripe session ID so the same checkout can never create two order documents:

const orderSchema = new mongoose.Schema({
  userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
  stripeSessionId: { type: String, required: true, unique: true },
  coins: { type: Number, required: true },
  status: { type: String, enum: ['pending', 'paid'], default: 'pending' },
  paidAt: Date,
});
Enter fullscreen mode Exit fullscreen mode

Takeaways

  • Webhooks are at-least-once, not exactly-once. Design for duplicates.
  • A "check, then update" across two queries is a race condition waiting to happen.
  • Put the condition inside the update filter with findOneAndUpdate — the database becomes your lock.
  • Use a transaction when multiple writes must succeed together.

This pattern isn't Stripe-specific. Anywhere you have "do this exactly once" logic — rewards, payouts, inventory, email sends — the same atomic-filter trick applies.

Have you hit a webhook race condition before? How did you handle it? Let me know in the comments 👇


I'm Sithija, a full-stack developer and founder of Eyerone, working with React, Next.js, Node.js, MongoDB and Cloudflare. More of my work at sithijakalhara.com.

Top comments (2)

Collapse
 
mujtbabbas profile image
Syed Mujtaba •

Good write-up — the part most teams miss is the one you flagged: the success page also calling fulfillOrder. Two writers with the same check-then-act gap will race no matter how careful each one is, so in our checkout flows we made the success page read-only and let the webhook be the only writer.

One addition worth considering: a processed-events collection keyed by Stripe event id (unique index), checked inside the same transaction. The status filter protects the order, but the event-id record also dedupes replays across event types and gives you an audit trail when a customer asks why they were credited twice.

Did you keep the success-page fallback, or drop it once the webhook path proved reliable?

Collapse
 
alexcodebytes profile image
Oleksandr •

the fact that the double credit came from your own success page calling fulfillOrder as a fallback is the best part lmao. we've all been there—adding a "just in case" endpoint and accidentally creating a race condition with the webhook. this is exactly why idempotency is so important. findOneAndUpdate with the status in the filter is such a clean fix.