n8n WhatsApp Integration: Accept Payments and Send Payment Status Automatically

Reshma Lill Mathew — Mon, 26 Oct 2026 06:11:20 +0000

A simple, step-by-step n8n WhatsApp integration: send a payment link, accept payments, and tell your customer if the payment worked.

n8n is great for automation. But when I wanted to take payments inside an n8n workflow, I got stuck.

n8n has no "take payment" button. I could create a payment link, but I had more questions:

How does n8n know when the customer has paid?
What if the payment fails?
Who handles tax when someone from another country buys?

In the end, I found a setup that works well. Kelviq handles the payment. n8n handles the steps. Webhooks connect the two. You don't need your own server, and you only need one small piece of code.

In this guide, I'll show you how to accept payments in n8n, one step at a time. I'll use a real example: a WhatsApp bot that sends a Pay Now button, and then tells the customer if their payment worked or failed.

The same steps also work for Telegram, email or a website.

For payments, I'm using Kelviq. I'm based in India, where Stripe is currently invite-only for new businesses, so I needed something I could sign up for and start using right away. Kelviq worked well for that. It's also a merchant of record (MoR), so it handles sales tax for each sale. The same idea works with any payment provider that has a checkout API and webhooks.

How it works: 3 simple steps

This works for anything you sell with n8n, like a course, an ebook or a product in a chatbot.

Create a payment link. n8n asks Kelviq for a payment link and sends it to the customer.
Get told when they pay. When the customer pays, Kelviq sends a message to n8n. This message is called a webhook. n8n then does the next thing, like sending a receipt.
Check for failed payments. If no message comes, n8n asks Kelviq what happened.

There is one catch you should know about. Kelviq does not send a message when a one-time payment fails. It only sends checkout.completed when the payment works. (There is a failure message called invoice.payment_failed, but it's only for subscriptions.)

So:

Success: Kelviq tells you.
Failure: you have to ask Kelviq.

Step 3 shows you how.

Step 1: Create a payment link in n8n

You don't need any extra node. n8n's built-in HTTP Request node is enough.

First, get a server API key from Settings > API Keys in Kelviq. Then set up the HTTP Request node like this:

Method: POST
URL: https://sandboxapi.kelviq.com/api/v1/checkout/ for testing, or https://api.kelviq.com/api/v1/checkout/ for real payments
Header: Authorization: Bearer <your server API key>
Body (JSON):

{
  "planIdentifier": "your-plan-identifier",
  "chargePeriod": "ONE_TIME",
  "customerId": "cust_{{ $json.userId }}",
  "successUrl": "https://yoursite.com/thanks",
  "cancelUrl": "https://yoursite.com/cancelled",
  "metadata": {
    "user_id": "{{ $json.userId }}",
    "order_ref": "{{ $json.orderId }}"
  }
}

The most useful part here is metadata. It's a place to store your own information, like an order number or user ID. Kelviq sends it back to you when the customer pays, so n8n knows who paid.

Only put IDs here. Never put passwords or card details in metadata.

A few more things to know:

planIdentifier, chargePeriod and successUrl are required.
Want to set your own price? Add customAmount, currencyCode and taxBehavior (INCLUSIVE or EXCLUSIVE).
Setting your own customerId makes it easier to find the customer later.

Kelviq sends back two things:

{
  "checkoutUrl": "https://kelviq.com/checkout/cs_eeCGdGayc5oTMdGNV5XocfRk6o87K0vlwwCuKeiE7BLU9/",
  "checkoutSessionId": "cs_eeCGdGayc5oTMdGNV5XocfRk6o87K0vlwwCuKeiE7BLU9"
}

checkoutUrl is the payment link. Send it to your customer.
checkoutSessionId is the ID of this payment. Save it. You'll need it in Step 3.

Step 2: Get told when someone pays (n8n webhook)

A webhook is just a message Kelviq sends to n8n when something happens, like a successful payment. Make a new n8n workflow for this.

1. Add a Webhook node

HTTP Method: POST
Respond: Immediately. This tells Kelviq "got it" right away, so it doesn't send the same message again.
Options > Raw Body: ON. You need this to check that the message really came from Kelviq.

Turn the workflow on (activate it) and copy the Production URL. Don't use the Test URL here, because it only works while you are testing in the editor.

2. Add the URL to Kelviq

In Kelviq, go to Settings > Webhooks. Add your n8n URL and choose the event checkout.completed. If you sell subscriptions, also choose invoice.payment_failed.

Kelviq will show you a secret key that starts with kq_whsec_. Copy it now, because Kelviq only shows it once.

3. Check that the message is real

This step is important. Without it, anyone who finds your webhook URL could send a fake "payment successful" message.

Kelviq adds a secret stamp (called a signature) to every message, inside three headers:

Header	What it is
`webhook-id`	The ID of the message
`webhook-timestamp`	When the message was sent
`webhook-signature`	The secret stamp, starting with `v1,`

Add a Code node after the Webhook node and paste this in. It checks the stamp using your secret key:

const crypto = require('crypto');
const SECRET = 'kq_whsec_xxx'; // better: load from n8n credentials or env

const h = $input.first().json.headers;
const id = h['webhook-id'];
const ts = h['webhook-timestamp'];
const sigHeader = h['webhook-signature'] || '';

const buf = await this.helpers.getBinaryDataBuffer(0, 'data');
const raw = buf.toString('utf8');

// Reject messages older than 5 minutes
if (Math.abs(Date.now() / 1000 - parseInt(ts, 10)) > 300) {
  throw new Error('Webhook timestamp too old');
}

const expected = crypto.createHmac('sha256', SECRET)
  .update(`${id}.${ts}.${raw}`, 'utf8')
  .digest('hex');
const received = sigHeader.split(',')[1] || '';

if (received.length !== expected.length ||
    !crypto.timingSafeEqual(Buffer.from(expected, 'hex'), Buffer.from(received, 'hex'))) {
  throw new Error('Invalid Kelviq signature');
}

return [{ json: JSON.parse(raw) }];

If you host n8n yourself, add this setting to your environment: NODE_FUNCTION_ALLOW_BUILTIN=crypto. Without it, the code can't run.

4. Stop double messages

Sometimes Kelviq sends the same message more than once (it retries up to 3 times if something goes wrong). You don't want your customer to get two receipts.

Add a Remove Duplicates node. Choose "Remove items processed in previous executions" and use {{ $json.id }} as the key.

5. Do something with the payment

Add a Switch node on {{ $json.type }}. For checkout.completed, you'll find the useful details here:

What you want	n8n expression
Your metadata	`{{ $json.data.object.metadata.order_ref }}`
Amount	`{{ $json.data.object.amount }}`
Currency	`{{ $json.data.object.currency }}`
Customer email	`{{ $json.data.object.customer.email }}`

Now you can do anything: send a receipt, add a row to Google Sheets, give access to a course, or tell your team.

One important rule: only trust the webhook as proof of payment. Don't trust the "thank you" page redirect, because anyone can open that page.

Step 3: Find failed payments

Remember, Kelviq doesn't send a message when a one-time payment fails. So n8n has to ask. Kelviq has two links (API endpoints) for this:

Endpoint	What it tells you
`GET /api/v1/checkout/sessions/{session_id}/`	The payment status: `open`, `processing`, `success` or `expired`
`GET /api/v1/checkout/sessions/{session_id}/events/`	A list of what happened, each marked `pending`, `success` or `failed`

Add these nodes at the end of your Step 1 workflow:

Wait about 15 minutes. n8n pauses and comes back later.
HTTP Request: get the payment status using the checkoutSessionId you saved in Step 1. Use the same Bearer header.
IF the status is success, stop. Step 2 already handled it.
If not, HTTP Request: get the list of events.
IF any event says failed, tell the customer and send the same payment link again. The link works for 24 hours.
If nothing failed, the customer just hasn't paid yet. You can send a friendly reminder, or do nothing.

You can change the wait time. For small, quick purchases, 10 to 15 minutes is good. For bigger purchases, wait a few hours.

n8n WhatsApp integration example: Pay Now button with payment status

This is the project that started it all. Customers chat with a WhatsApp bot made in n8n. The bot sends a Pay Now button, and they pay through Kelviq.

The problem was what happened after. Customers paid, and then nothing happened in the chat. They didn't know if it worked, and they kept asking "did my payment go through?"

Now the bot tells them automatically. Here's how.

Save the phone number in metadata

When the bot creates the payment link, it saves the customer's WhatsApp number in metadata. The wa.me links bring the customer back to the chat after paying:

{
  "planIdentifier": "your-plan-identifier",
  "chargePeriod": "ONE_TIME",
  "customerId": "wa_{{ $json.phone }}",
  "successUrl": "https://wa.me/91XXXXXXXXXX?text=Done",
  "cancelUrl": "https://wa.me/91XXXXXXXXXX",
  "metadata": {
    "wa_phone": "{{ $json.phone }}",
    "order_ref": "{{ $json.orderId }}"
  }
}

Then a WhatsApp Business Cloud node sends the button, with checkoutUrl as the link.

Send a message when the payment works

In the Step 2 workflow, the checkout.completed branch gets the phone number with {{ $json.data.object.metadata.wa_phone }} and sends:

Payment of {{ $json.data.object.amount }} {{ $json.data.object.currency }} received for order {{ $json.data.object.metadata.order_ref }}. Thank you!

Send a message when the payment fails

When Step 3 finds a failed payment, the bot sends:

Your payment for order {{ order_ref }} didn't go through. You can try again here: {{ checkoutUrl }}

For subscriptions, the failure message (invoice.payment_failed) doesn't include metadata. That's why I set customerId to wa_ plus the phone number. Remove the wa_ from data.object.customer.customer_id and you have the number again. This message also gives you the reason (failure_details.message) and a link to pay again (payment_link).

Bonus: know right away when someone cancels

Set cancelUrl to a second n8n Webhook (GET) URL, like https://your-n8n.com/webhook/kelviq-cancel?phone=919876543210. When someone clicks cancel, this small workflow sends them a "payment not completed" message and takes them back to the WhatsApp chat.

Remember the 24-hour rule

On WhatsApp, you can only send normal messages within 24 hours of the customer's last message. Usually you are fine, because they just used your bot. But to be safe, create approved message templates (like payment_success and payment_failed) in Meta Business Manager.

Checklist before you go live

Test everything in Kelviq's sandbox with a test card. Then check Settings > Webhooks to see if each message arrived.
Click Resend on a message and make sure the customer only gets one reply.
Test a failed card and a payment the customer never finishes, not just a successful one.
Move your secret key out of the Code node and into n8n credentials or an environment variable.
Switch the API URL and API key to the real (production) ones at the same time. Test and real keys are different.
Add a new webhook in Kelviq for production. It gets its own secret key.

FAQ

Can n8n accept payments? Not by itself. n8n runs the steps, and a payment provider like Kelviq takes the actual payment. You connect them with the HTTP Request and Webhook nodes.

How do I know if a payment failed? For one-time payments, ask Kelviq's API after a short wait (see Step 3). For subscriptions, listen for invoice.payment_failed.

Does this work on n8n Cloud and self-hosted n8n? Yes. On self-hosted n8n, add NODE_FUNCTION_ALLOW_BUILTIN=crypto so the Step 2 code can run.

Can I use this with Telegram, email or a website? Yes. The payment steps are the same. You only change the node that sends the link and the messages.

Wrapping up

Adding payments to my n8n WhatsApp integration was easier than I thought. Here is the whole idea in four lines:

Create the payment link with an HTTP Request node.
Save your own IDs in metadata.
Trust only checked webhooks for successful payments.
Ask Kelviq's API when a payment goes quiet.

Now my customers don't have to ask "did my payment go through?" anymore. The chat tells them.

If you build this, I'd love to hear what you are selling and which step was the hardest. Tell me in the comments.

DEV Community: Reshma Lill Mathew