Skip to main content
Webhooks are an important part of your payment integration. They allow Flutterwave to notify you about events that happen on your account, like a successful payment or a failed transaction. A webhook URL is an endpoint on your server where you can receive notifications about such events. When an event occurs, we’ll make a POST request to that endpoint, with a JSON body containing the details about the event, including the type of event and the data associated with it.

​
When to Use Webhooks

Webhooks are supported for all kinds of payment methods, but they’re especially useful for methods and events that happen outside your application’s control, such as:
  • Getting paid via mobile money or USSD
  • A customer being charged for their subscription (recurring payments).
  • A pending payment transitioning to successful.
These are all asynchronous actions, as your application does not control them, so you won’t know when they are completed unless we notify you or you check later. Setting up a webhook allows us to notify you when these payments are completed. Within your webhook endpoint, you can then:
  • Update a customer’s membership records in your database when a subscription payment succeeds.
  • Email a customer when a subscription payment fails.
  • Update your order records when the status of a pending payment is updated to successful.

​
Structure of a Webhook Payload

All webhook payloads (except virtual card debit) follow the same basic structure:
  • An event field describing the type of event.
  • A data object. The content of this object will vary depending on the event, but typically, it will contain details of the event, including:
    • an id containing the ID of the transaction.
    • a status describing the status of the transaction.
    • payment or customer details, if applicable.
Here are some sample webhook payloads for transfers and payments: 
{
  "event": "charge.completed",
  "data": {
    "id": 285959875,
    "tx_ref": "Links-616626414629",
    "flw_ref": "PeterEkene/FLW270177170",
    "device_fingerprint": "a42937f4a73ce8bb8b8df14e63a2df31",
    "amount": 100,
    "currency": "NGN",
    "charged_amount": 100,
    "app_fee": 1.4,
    "merchant_fee": 0,
    "processor_response": "Approved by Financial Institution",
    "auth_model": "PIN",
    "ip": "197.210.64.96",
    "narration": "CARD Transaction ",
    "status": "successful",
    "payment_type": "card",
    "created_at": "2020-07-06T19:17:04.000Z",
    "account_id": 17321,
    "customer": {
      "id": 215604089,
      "name": "Yemi Desola",
      "phone_number": null,
      "email": "user@gmail.com",
      "created_at": "2020-07-06T19:17:04.000Z"
    },
    "card": {
      "first_6digits": "123456",
      "last_4digits": "7889",
      "issuer": "VERVE FIRST CITY MONUMENT BANK PLC",
      "country": "NG",
      "type": "VERVE",
      "expiry": "02/23"
    }
  }
}

​
Enabling Webhooks

Here is how to set up a webhook on your Flutterwave account:
  1. Log in to you dashboard and click on Settings.
  2. Navigate to Webhooks to add your webhook URL.
  3. Check all the boxes and save your Settings. alt
TipWhen testing, you can get an instant webhook URL by visiting webhook.site. This will allow you to inspect the received payload without having to write any code or set up a server.

​
Implementing a Webhook

Creating a webhook endpoint on your server is the same as writing any other API endpoint, but there are a few important details to note:

​
Verifying Webhook Signatures

When enabling webhooks, you have the option to set a secret hash. Since webhook URLs are publicly accessible, the secret hash allows you to verify that incoming requests are from Flutterwave. You can specify any value as your secret hash, but we recommend something random. You should also store it as an environment variable on your server. If you specify a secret hash, we’ll include it in our request to your webhook URL, in a header called verif-hash. In the webhook endpoint, check if the verif-hash header is present and that it matches the secret hash you set. If the header is missing, or the value doesn’t match, you can discard the request, as it isn’t from Flutterwave.

​
Responding to Webhook Requests

To acknowledge receipt of a webhook, your endpoint must return a 200 HTTP status code. Any other response codes, including 3xx codes, will be treated as a failure. We don’t care about the response body or headers.
Be sure to enable webhook retries on your dashboard. If we don’t get a 200 status code (for example, if your server is unreachable), we’ll retry the webhook call 3 times, with a 30-minute interval between each attempt.

​
Examples

Here are a few examples of implementing a webhook endpoint in some web frameworks:
Web frameworks like Rails or Django check POST requests for CSRF tokens, a security measure against cross-site request forgery. Exclude webhook endpoints from CSRF protection.
// In an Express-like app:

app.post("/flw-webhook", (req, res) => {
    // If you specified a secret hash, check for the signature
    const secretHash = process.env.FLW_SECRET_HASH;
    const signature = req.headers["verif-hash"];
    if (!signature || (signature !== secretHash)) {
        // This request isn't from Flutterwave; discard
        res.status(401).end();
    }
    const payload = req.body;
    // It's a good idea to log all received events.
    log(payload);
    // Do something (that doesn't take too long) with the payload
    res.status(200).end()
});

​
Best Practices

​
Don’t Rely Solely on Webhooks

Have a backup strategy in place in case your webhook endpoint fails. For instance, if your webhook endpoint is throwing server errors, you won’t know about any new customer payments because webhook requests will fail. To get around this, we recommend setting up a background job that polls for the status of any pending transactions at regular intervals (for instance, every hour) using the transaction verification endpoint till a successful or failed response is returned.

​
Use a Secret Hash

Remember, your webhook URL is public, and anyone can send a fake payload. We recommend using a secret hash so you can be sure the requests you get are from Flutterwave.

​
Always Re-query

Whenever you receive a webhook notification, before giving the customer value, where possible, you should call our API again to verify the received details and ensure that the data returned has not been compromised. For instance, when you receive a successful payment notification, you can use our transaction verification endpoint to verify the status of the transaction before confirming the customer’s order. 
const payload = req.body;
const response = await flw.Transaction.verify({id: payload.id});
if (
    response.data.status === "successful"
    && response.data.amount === expectedAmount
    && response.data.currency === expectedCurrency) {
    // Success! Confirm the customer's payment
} else {
    // Inform the customer their payment was unsuccessful
}

​
Respond Quickly

Your webhook endpoint needs to respond within a certain time limit, or we’ll consider it a failure and try again. Avoid doing long-running tasks or network calls in your webhook endpoint so you don’t hit the timeout. If your framework supports it, you can have your webhook endpoint immediately return a 200 status code, and then perform the rest of its duties; otherwise, you should dispatch any long-running tasks to a job queue and then respond.

​
Be Idempotent

Occasionally, we might send the same webhook event more than once. You should make your event processing idempotent (calling the webhook multiple times will have the same effect), so you don’t end up giving a customer value multiple times. One way of doing this is recording the events you’ve processed and then checking if the status has changed before processing the duplicate event: 
const payload = req.body;
const existingEvent = await PaymentEvent.where({id: payload.id}).find();
if (existingEvent.status === payload.status) {
    // The status hasn't changed,
    // so it's probably just a duplicate event
    // and we can discard it
    res.status(200).end();
}

// Record this event
await PaymentEvent.save(payload);
// Process event...