Marketplace affiliate deals on WhatsApp with the WhatsApp API

Use case

When to use this flow

Your backend already ingests marketplace deal signals

Use this flow when your own backend detects or ingests cheap-deal and discount signals from Amazon, AliExpress, or similar sources and applies price, discount, and dedupe rules before anything reaches WhatsApp.

You monetize with affiliate links and optional short domains

Use this flow when every product URL must pass through your affiliate tag and optional link shortener on your backend before subscribers see it in WhatsApp.

The destination is a WhatsApp Channel, a deal group, or both

Use this flow when followers should see the offer in a WhatsApp Channel and/or a deals group as a link-preview post, not as a cold DM blast to individual numbers.

WhatsApp Channel or group chat on a phone showing a link-preview deal post with product title, price, and an affiliate product link.

Customer experience

Followers see the deal preview in chat

Before automation, a hot marketplace price shows up in your ingest pipeline while subscribers wait for someone to rewrite the affiliate link and paste a formatted post by hand.

After the flow runs, Channel subscribers and group members see a link-preview post with the product title, price, and your tracking URL they can tap to buy. Integrators build this result with the WhatsApp API.

Workflow

From a marketplace deal to a link preview

Qualified marketplace deal

Your backend ingests or detects a deal from Amazon, AliExpress, or a similar source, injects your affiliate tag and optional short link, and prepares title, price, and preview media. Whapi.Cloud does not scrape marketplaces or rewrite affiliate ids.

Resolve the Channel id once

GET /newsletters

getNewsletters lists your Channels so you can pick the deals Channel JID, store it on your backend, and skip this call on every later deal unless the Channel changes.

Resolve the deal group id when needed

GET /groups

getGroups lists your groups so you can store the deal group JID when group fan-out is enabled—call once or when the target group changes, not on every SKU.

Post the deal link preview

POST /messages/link_preview

sendMessageLinkPreview sends the rewritten product URL in the body with title and optional media to each configured destination JID; repeat the call when both Channel and group should receive the same deal.

View code examples

Need delivery tracking? A successful send response is not proof followers already see the deal post. Track later acks on delivery webhooks. Learn about delivery status →

Prerequisites

Before you run the flow

Connect the WhatsApp number that administers your deals Channel or group and authenticate every request with that number's API token. Marketplace ingest, affiliate rewrite, and short-link logic stay on your backend.

1. Create a Whapi.Cloud account: Sign up
2. Connect your WhatsApp account: Open the guide
3. Find your API token: Open the section

Optional — go deeper for this flow

WhatsApp Channels API overview: See the overview
Automate WhatsApp groups with the API: Open the guide
WhatsApp Groups API overview: See the overview

API implementation

The calls that publish the deal

Your backend already qualified the deal and holds the rewritten affiliate URL. These calls resolve destination JIDs when you need them, then deliver the SKU as a link-preview post to your Channel and/or deal group.

Get your API token for free after you register on whapi.cloud, and use that token in the code instead of Your_Token from the examples.

Resolve the Channel id once

List your Channels so you can store the deals Channel JID once before deal posts start.

curl --request GET \
     --url https://gate.whapi.cloud/newsletters \
     --header 'accept: application/json' \
     --header 'authorization: Bearer Your_Token'

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://gate.whapi.cloud/newsletters",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: application/json",
    "authorization: Bearer Your_Token"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

import requests

url = "https://gate.whapi.cloud/newsletters"

headers = {
    "accept": "application/json",
    "authorization": "Bearer Your_Token",
}

response = requests.get(url, headers=headers)

print(response.text)

const url = 'https://gate.whapi.cloud/newsletters';

const response = await fetch(url, {
  method: 'GET',
  headers: {
    accept: 'application/json',
    authorization: 'Bearer Your_Token',
  },
});

console.log(await response.text());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://gate.whapi.cloud/newsletters")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("authorization", "Bearer Your_Token")
  .build();

Response response = client.newCall(request).execute();

using RestSharp;

var options = new RestClientOptions("https://gate.whapi.cloud/newsletters");
var client = new RestClient(options);
var request = new RestRequest("");
request.AddHeader("accept", "application/json");
request.AddHeader("authorization", "Bearer Your_Token");
var response = await client.GetAsync(request);

Console.WriteLine("{0}", response.Content);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://gate.whapi.cloud/newsletters", nil)
	req.Header.Set("accept", "application/json")
	req.Header.Set("authorization", "Bearer Your_Token")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

Resolve the deal group id when needed

List your groups so you can store the deal group JID when group fan-out is part of your setup.

curl --request GET \
     --url https://gate.whapi.cloud/groups \
     --header 'accept: application/json' \
     --header 'authorization: Bearer Your_Token'

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://gate.whapi.cloud/groups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: application/json",
    "authorization: Bearer Your_Token"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

import requests

url = "https://gate.whapi.cloud/groups"

headers = {
    "accept": "application/json",
    "authorization": "Bearer Your_Token",
}

response = requests.get(url, headers=headers)

print(response.text)

const url = 'https://gate.whapi.cloud/groups';

const response = await fetch(url, {
  method: 'GET',
  headers: {
    accept: 'application/json',
    authorization: 'Bearer Your_Token',
  },
});

console.log(await response.text());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://gate.whapi.cloud/groups")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("authorization", "Bearer Your_Token")
  .build();

Response response = client.newCall(request).execute();

using RestSharp;

var options = new RestClientOptions("https://gate.whapi.cloud/groups");
var client = new RestClient(options);
var request = new RestRequest("");
request.AddHeader("accept", "application/json");
request.AddHeader("authorization", "Bearer Your_Token");
var response = await client.GetAsync(request);

Console.WriteLine("{0}", response.Content);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://gate.whapi.cloud/groups", nil)
	req.Header.Set("accept", "application/json")
	req.Header.Set("authorization", "Bearer Your_Token")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

Post the deal link preview

Send the product title, price, and rewritten URL to each stored destination JID as a link-preview announcement for each qualified deal.

curl --request POST \
     --url https://gate.whapi.cloud/messages/link_preview \
     --header 'accept: application/json' \
     --header 'authorization: Bearer Your_Token' \
     --header 'content-type: application/json' \
     --data '
{
  "to": "1203632001928471@newsletter",
  "title": "Deal: wireless earbuds",
  "body": "Wireless earbuds now $29.99 \u2014 tap to buy: https://deals.example/a/xyz123",
  "media": "https://deals.example/a/xyz123/image.jpg"
}
'

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://gate.whapi.cloud/messages/link_preview",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    "to" => "1203632001928471@newsletter",
    "title" => "Deal: wireless earbuds",
    "body" => "Wireless earbuds now $29.99 — tap to buy: https://deals.example/a/xyz123",
    "media" => "https://deals.example/a/xyz123/image.jpg",
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: application/json",
    "authorization: Bearer Your_Token",
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

import requests

url = "https://gate.whapi.cloud/messages/link_preview"

payload = {
  "to": "1203632001928471@newsletter",
  "title": "Deal: wireless earbuds",
  "body": "Wireless earbuds now $29.99 — tap to buy: https://deals.example/a/xyz123",
  "media": "https://deals.example/a/xyz123/image.jpg",
}
headers = {
    "accept": "application/json",
    "authorization": "Bearer Your_Token",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const url = 'https://gate.whapi.cloud/messages/link_preview';

const response = await fetch(url, {
  method: 'POST',
  headers: {
    accept: 'application/json',
    authorization: 'Bearer Your_Token',
    'content-type': 'application/json',
  },
  body: JSON.stringify({
    to: '1203632001928471@newsletter',
    title: 'Deal: wireless earbuds',
    body: 'Wireless earbuds now $29.99 — tap to buy: https://deals.example/a/xyz123',
    media: 'https://deals.example/a/xyz123/image.jpg',
  }),
});

console.log(await response.text());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"to\": \"1203632001928471@newsletter\", \"title\": \"Deal: wireless earbuds\", \"body\": \"Wireless earbuds now $29.99 \u2014 tap to buy: https://deals.example/a/xyz123\", \"media\": \"https://deals.example/a/xyz123/image.jpg\"}");
Request request = new Request.Builder()
  .url("https://gate.whapi.cloud/messages/link_preview")
  .post(body)
  .addHeader("accept", "application/json")
  .addHeader("authorization", "Bearer Your_Token")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

using RestSharp;

var options = new RestClientOptions("https://gate.whapi.cloud/messages/link_preview");
var client = new RestClient(options);
var request = new RestRequest("");
request.AddHeader("accept", "application/json");
request.AddHeader("authorization", "Bearer Your_Token");
request.AddHeader("content-type", "application/json");
request.AddJsonBody(new {
  to = "1203632001928471@newsletter",
  title = "Deal: wireless earbuds",
  body = "Wireless earbuds now $29.99 — tap to buy: https://deals.example/a/xyz123",
  media = "https://deals.example/a/xyz123/image.jpg",
});
var response = await client.PostAsync(request);

Console.WriteLine("{0}", response.Content);

package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
)

func main() {
	body := []byte(`{"to": "1203632001928471@newsletter", "title": "Deal: wireless earbuds", "body": "Wireless earbuds now $29.99 \u2014 tap to buy: https://deals.example/a/xyz123", "media": "https://deals.example/a/xyz123/image.jpg"}`)
	req, _ := http.NewRequest("POST", "https://gate.whapi.cloud/messages/link_preview", bytes.NewReader(body))
	req.Header.Set("accept", "application/json")
	req.Header.Set("authorization", "Bearer Your_Token")
	req.Header.Set("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}

Get API KEY for free

Delivery status

When the deal post leaves pending

A successful send response does not mean followers already have the deal post. The first status visible before a webhook is pending. Later status changes arrive only on statuses.post and statuses.put. If the status stays pending and does not move to sent, delivered, or a later ack, the message was not delivered—check the payload and the account's permission to send that type.

Treat a stuck pending as not delivered, not as a clock or a queue waiting on a webhook.
Subscribe to statuses.post and statuses.put when you need sent or delivered confirmation for Channel or group posts.
Do not mark the marketplace deal as fully published while the WhatsApp status stays pending.

What to read on delivery and webhooks

What a delivered webhook looks like: See the callback
Which events we send to a webhook: See tracked events
How to set a webhook on a channel: Open the guide
Where to get the webhook URL: Open the guide
Webhook payload examples: See the formats

Contact our support if something went wrong

When things break

Handle failures at each step

If the deal passed ingest but affiliate rewrite failed, getNewsletters or getGroups cannot match a destination, the wrong JID was stored, sendMessageLinkPreview is rejected on one surface while another succeeded, or the post never leaves pending, retry or alert and do not mark the deal as fully published.

The deal was ready, but WhatsApp stayed quiet?

Keep marketplace deal state separate from WhatsApp delivery. Confirm affiliate and short-link output on your backend, verify stored Channel and group JIDs, retry sendMessageLinkPreview for the failed destination, or alert ops—do not mark the SKU published while followers still have no post. If the deal post still fails after a retry, contact Whapi support with the destination id and the failed request id.

Contact our support if something went wrong

Troubleshoot by API step

Status	What it means	What to do
`400`	Wrong request parameters	Fix wrong request parameters on the newsletters list call before retrying.
`500`	Internal Error

Status	What it means	What to do
`400`	Wrong request parameters	Fix wrong request parameters in the link-preview body before retrying.
`401`	Need channel authorization for send message	Authorize the channel for send message, then retry with a valid token.
`402`	Trial version limit exceeded
`403`	It is forbidden to send to this group/recipient	Confirm it is allowed to send to this Channel or group recipient, then retry with a corrected to value.
`404`	Media with specified id not found
`413`	Request media too large
`415`	Unsupported media type
`429`	Too many requests	Slow down and retry later after too many requests.
`500`	Internal Error

Status	What it means	What to do
`400`	Wrong request parameters	Fix wrong request parameters on the groups list call before retrying.
`500`	Internal Error

FAQ

Marketplace deals and WhatsApp publishing

No. Your backend ingests deal signals, applies affiliate and short-link rules, and decides when a SKU is ready to post. Whapi.Cloud receives the WhatsApp send after you call sendMessageLinkPreview with the rewritten URL in the body.

No. Resolve and store destination JIDs once (or when the Channel or group changes), then reuse those ids for later link-preview posts. Listing on every deal tick adds latency without changing the scenario.

Follow the catalog failure_mode—do not mark the deal as fully published, retry or alert, and check affiliate rewrite output, stored JIDs, rejected sends, or a status that stays pending.

RSS-to-Channel flows trigger on feed items and reference CMS article URLs. This flow triggers on marketplace deal signals with affiliate URLs and may fan out to a deals group as well as a Channel.

Mirroring to Telegram or other messengers stays on your backend. This job covers WhatsApp Channel and/or group link-preview posts only.

Get started with the API

Supported WhatsApp Features

Everything you need to build WhatsApp automation

Whapi.Cloud gives you access to a complete set of WhatsApp features — messaging, media, groups, channels, webhooks and more. Build bots, automations and integrations without feature limitations.

Chosen by developers

Trusted by 3,300+ developers and SaaS teams

Developers worldwide rely on Whapi.Cloud to build automations, bots, CRM integrations, bulk messaging tools and advanced WhatsApp workflows. Our infrastructure processes millions of API requests with high stability — and grows every month.

5,5K+

active API channels

21M+

API requests processed monthly

Start Free Trial Read all reviews

“Everything is simple, intuitive and easy to navigate. The docs are clear, and all the info I need is right on the screen. Great job.”

roberto k. / Web Developer

“We connected WhatsApp to our workflows using n8n in just a few minutes. No code, no complications- everything worked on the first try.”

Martin p. / Developer

“Whapi.Cloud became a key part of our customer communication. We automated product updates, order notifications and support messages without needing Meta templates or approvals”

Oscar T. / CTO

More deals and publishing flows

WordPress RSS to WhatsApp Channel with link preview (sibling, not marketplace deals)

Publish plain text to a Channel when CMS content goes live (sibling, not link preview deals)

WhatsApp Channels API — publish updates and manage Channels

Automate WhatsApp groups — deal group fan-out and stored group JIDs

WhatsApp Groups API overview — list groups before posting deals

Marketplace and e-commerce WhatsApp automation case studies

When to use this flow

Followers see the deal preview in chat

From a marketplace deal to a link preview

Before you run the flow

The calls that publish the deal

Resolve the Channel id once

Resolve the deal group id when needed

Post the deal link preview

When the deal post leaves pending

What to read on delivery and webhooks

Handle failures at each step

Troubleshoot by API step

List Channels and pick the JID to store for deal posts. getNewsletters · GET /newsletters

Post the deal link preview to each stored destination JID. sendMessageLinkPreview · POST /messages/link_preview

List groups and pick the deal group JID to store when group fan-out is enabled. getGroups · GET /groups

Marketplace deals and WhatsApp publishing

Does Whapi.Cloud find Amazon or AliExpress deals for me?

Do I call getNewsletters and getGroups on every deal?

What if ingest succeeded but followers never saw the deal?

How is this different from posting RSS items to a Channel?

Can I mirror the same deal to Telegram from Whapi?

Everything you need to build WhatsApp automation

WhatsApp Channels API

WhatsApp Groups & Communities

No templates or approvals

Real-time webhooks

All Media & Message Types

Orders & product automation

WhatsApp number validation

Low-code & no-code friendly

WhatsApp Statuses API

Delivery & read status

Multi-device connection

Interactive messages & buttons

Trusted by 3,300+ developers and SaaS teams

5,5K+

21M+

“Everything is simple, intuitive and easy to navigate. The docs are clear, and all the info I need is right on the screen. Great job.”

“We connected WhatsApp to our workflows using n8n in just a few minutes. No code, no complications- everything worked on the first try.”

“Whapi.Cloud became a key part of our customer communication. We automated product updates, order notifications and support messages without needing Meta templates or approvals”

More deals and publishing flows