> ## Documentation Index
> Fetch the complete documentation index at: /docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Make and ClickFlare Integration Guide

> Connect Make to ClickFlare: start scenarios from ClickFlare events with a custom webhook, and post conversions or call the API with the HTTP app.

![Make and ClickFlare Integration](https://mintcdn.com/clickflare/gS923ib4WFySqxSL/images/integrations/covers/make.png?fit=max\&auto=format\&n=gS923ib4WFySqxSL\&q=85\&s=36365a5ce76ff1b329cb47b4fafe997a)

Make (formerly Integromat) is a visual automation platform. You build **scenarios** from modules on a canvas: a trigger module starts the scenario and the modules after it move and reshape data between apps. Two of Make's own apps connect it to ClickFlare: **Webhooks**, which gives you a URL that starts a scenario, and **HTTP**, which calls any URL or API.

The connection works in both directions:

* **ClickFlare → Make.** ClickFlare's [Custom Webhook](/docs/en/integrations/custom-webhook-integration.md) sends an event (a conversion, a purchase, a click) to a Make **Custom webhook**. The scenario takes it from there: a sheet, a CRM, a partner endpoint, a Slack alert.
* **Make → ClickFlare.** An HTTP **Make a request** module posts a conversion to ClickFlare's postback endpoint as JSON, so any app Make connects to can report conversions. The same module can call the ClickFlare REST API with your API key stored in a keychain.

***

## At a glance

To set up Make with ClickFlare:

1. Create a custom webhook in Make.
2. Map the event in ClickFlare.
3. Teach Make the data structure.
4. Post conversions to ClickFlare.

| | Make + ClickFlare |
| - | - |
| **How it connects** | Custom Webhook out, HTTP Make a request in |
| **What reaches ClickFlare** | ClickFlare events out; conversions and API calls in |
| **Timing** | Instantly, or on a schedule you set in Make |
| **Key parameters** | `cf_click_id`, `payout`, `ct`, param1 to param20, api-key |
| **Works with** | Visits, clicks, conversions, custom conversions |
| **Good to know** | Webhooks without a scenario for 5 days return 410 Gone. |

***

## How the data flows

```text theme={null}
ClickFlare → Make
  Conversion recorded in ClickFlare
  → Custom Webhook fires (POST, with macros)
     https://hook.eu1.make.com/abc123...
  → Request lands in the webhook's queue
  → Scenario runs: sheet row, CRM record, partner callback...

Make → ClickFlare
  Trigger in any app (new deal, new payment, partner webhook)
  → HTTP > Make a request: POST, application/JSON
     https://trk.yourdomain.com/cf/cv
     {"cf_click_id": "CF_CLICK_ID", "payout": 25, "ct": "sale"}
  → ClickFlare matches the conversion to the original click
```

| Direction | Make side | ClickFlare side | Use it for |
| - | - | - | - |
| **Out of ClickFlare** | Webhooks → Custom webhook | Custom Webhook (Integrations → Conversion API) | Logging, alerts, CRM sync, partner callbacks |
| **Into ClickFlare** | HTTP → Make a request (POST) | JSON POST to `/cf/cv` | Conversions from apps with no postback of their own |
| **Reading data** | HTTP → Make a request with an API key keychain | REST API at `public-api.clickflare.io` | Reports, offer sync, bulk changes |

***

## What you'll need

* A ClickFlare account with your **own tracking domain** for postbacks. See [Tracking domains](/docs/en/settings/tracking-domains.md).
* A Make account. Each module run uses credits from your Make plan, so check your plan's allowance against your event volume.
* For Make → ClickFlare: the click ID stored somewhere the trigger app can return it, for example a hidden form field or a CRM field.
* For API calls: an API key from **Settings → API Keys**.

***

## Send ClickFlare events to Make

**1. Create a custom webhook in Make**

Create a scenario and add the **Webhooks** app's **Custom webhook** module as the trigger. Click **Add** to create a new webhook, give it a name such as "ClickFlare conversions" and save. Make shows the webhook URL: copy it.

**2. Add a Webhooks integration in ClickFlare**

Go to **Integrations**, click **Conversion API → New integration** and choose **Webhooks**. Pick the **Workspace** and give it a **Name**.

**3. Map the event**

Under **Event Type Mapping**, pick the **ClickFlare Event**, set **Request Method** to **POST**, paste the Make URL as the **Webhook URL** and add the values you need with macros, for example:

```text theme={null}
https://hook.eu1.make.com/abc123?click_id={cf_click_id}&payout={payout_currency}
```

Macros work in the URL, headers and body. With a JSON body, ClickFlare sets `Content-Type: application/json` for you. To send only some events, click **Add Conditions** and set a filter, such as payout greater than 0 or one campaign. Click **Next**, then **Save**.

![A ClickFlare Webhooks integration for Make: the Sale event, POST, the Make webhook URL and a JSON body with click\_id, payout and campaign macros](https://mintcdn.com/clickflare/b2lpDlx8sR69TsUK/images/integrations/make/clickflare-make-webhook-event-mapping.png?fit=max\&auto=format\&n=b2lpDlx8sR69TsUK\&q=85\&s=4f119cad93d9d9ccd90790072f1e102a)

**4. Teach Make the data structure**

Make learns the fields of a custom webhook from the first request it receives. With the Custom webhook module open and listening, fire a real event from ClickFlare. Make then lists the fields so you can map them in later modules. If you add macros later, use **Redetermine data structure** on the module and send a new event.

**5. Build the rest and turn it on**

Add your modules, then switch the scenario on. With an instant webhook, each ClickFlare event starts a run right away.

### How Make handles incoming events

* **Queue.** Every request first lands in the webhook's own queue. Open **Webhooks** in Make's left sidebar, pick the webhook and switch to the **Queue** tab to see what's waiting.
* **Instant or scheduled.** By default the scenario runs as each request arrives. If you schedule it instead, requests wait in the queue and are processed when the schedule triggers, up to the **Maximum number of results** per run (default 2). Raise it if the queue grows.
* **Parallel runs.** Instant webhooks run in parallel. Turn on **Process data in order** in the scenario settings if order matters.
* **Queue limits.** Make allows up to 667 queued items per webhook for every 10,000 credits licensed per month, with a maximum of 10,000. When the queue is full, Make rejects new requests with `400 Queue is full`.
* **Inactive webhooks.** A webhook that isn't attached to any scenario for more than 5 days is deactivated and returns `410 Gone`.
* **Logs.** Make keeps webhook logs for 3 days (30 days on Enterprise), on the webhook's **Logs** tab.

***

## Report conversions from Make to ClickFlare

ClickFlare accepts conversions as a JSON POST on the same endpoint as its postback:

```bash theme={null}
curl -X POST 'https://trk.yourdomain.com/cf/cv' \
  -H 'Content-Type: application/json' \
  --data '{"cf_click_id": "abc", "ct": "search", "param1": "test", "payout": 1}'
```

The body keys are `cf_click_id` (required), `payout`, `ct`, `txid` and `param1` to `param20`. `ct` must match a custom conversion created under **Settings → Custom Conversions**. See [Custom conversions](/docs/en/settings/custom-conversions.md).

**1. Make sure the click ID reaches the other app**

The app that starts the scenario must know the ClickFlare click ID. Pass `{cf_click_id}` in the offer or lander URL and store it, for example in a hidden form field, a CRM field or a partner platform's sub ID.

**2. Set up the trigger**

Use the app's own trigger module, or a Custom webhook if the platform sends webhooks, as in the [Hotmart](/docs/en/integrations/hotmart-click-flare-integration-guide.md) and [PartnerStack](/docs/en/integrations/partnerstack-click-flare-integration-guide.md) guides.

**3. Add HTTP > Make a request**

Add the **HTTP** app's **Make a request** module and fill in:

| Field | Value |
| - | - |
| **Authentication type** | No authentication |
| **URL** | `https://trk.yourdomain.com/cf/cv` |
| **Method** | POST |
| **Body content type** | application/JSON |
| **Body input method** | **Data structure** (map each key) or **JSON string** (type the body) |
| **Parse response** | Yes, so you can check the reply |

With **JSON string**, map the values into the body:

```json theme={null}
{"cf_click_id": "{{1.click_id}}", "payout": {{1.amount}}, "txid": "{{1.order_id}}", "ct": "sale"}
```

`{{1.click_id}}` stands for whatever field holds the click ID in your trigger, and `{{1.order_id}}` for its order or transaction ID. With **JSON string** you must escape reserved characters yourself. **Data structure** escapes them for you, so prefer it when values come from user input.

**4. Run once and check**

Click **Run once** with a real click ID from a recent ClickFlare click. The conversion should appear on that campaign and in **Logs → Event Logs**.

> [!TIP]
>
> Need several conversions on the same click kept apart? Send a unique `txid` in the body: a different `txid` adds a conversion, the same `txid` replaces the earlier one. A GET to `/cf/cv` with `click_id`, `payout`, `ct` and `txid` in **Query parameters** works too. See [Postback parameters](/docs/en/tracking/click-flare-parameters-in-postback-urls.md).

### Map nested fields from other platforms

Make reads nested JSON and arrays natively, so it can map a platform's own payload straight into ClickFlare's keys. For example, for a PartnerStack reward, `cf_click_id` is the first item of `data.customer.sub_ids` and `payout` is `data.amount` divided by 100. Make's `get()` function and arithmetic in the mapping panel handle both without extra modules.

***

## Call the ClickFlare API from Make

**1. Create an API key keychain**

In **HTTP > Make a request**, set **Authentication type** to **API key** and click **Credentials** (or **Add**) to create a keychain:

| Field | Value |
| - | - |
| **Name** | "ClickFlare API" |
| **Key** | Your key from **Settings → API Keys**, with no prefix |
| **API key placement** | In the header |
| **API key parameter name** | `api-key` |

Make stores the key once and adds it to every module that uses the keychain. You can edit it later under **Keys** in the left sidebar. See [API overview](/docs/en/api/clickflare-api-overview.md).

**2. Make the request**

Set the **URL** to the endpoint, for example `https://public-api.clickflare.io/api/report` with **Method** POST and **Body content type** application/JSON. A daily campaign report:

```json theme={null}
{
  "startDate": "2026-11-01 00:00:00",
  "endDate": "2026-11-01 23:59:59",
  "timezone": "UTC",
  "groupBy": ["campaignID"],
  "metrics": ["campaignID", "campaignName", "visits", "conversions", "revenue", "cost", "roi"],
  "sortBy": "revenue",
  "orderType": "desc",
  "page": 1,
  "pageSize": 100,
  "includeAll": false
}
```

Every breakdown in `groupBy` must also be in `metrics`. For long reports, raise `page` until no rows come back, or use the module's **Pagination** settings with a page-based type.

> [!WARNING]
>
> An API key has the same rights as your account. Keep it in the keychain, not in the URL or headers of a module, so it isn't exposed in scenario logs.

***

## Verify the setup

**1. ClickFlare → Make**

Fire a test event and open the scenario's history. The run should show real values for the click ID and payout, not the macro text.

**2. Make → ClickFlare**

Run the HTTP module once with a recent click ID. The conversion should appear under the right custom conversion with the right payout.

***

## Troubleshooting

> [accordion] ClickFlare events don't start the scenario
>
> * The scenario is off, or the webhook was deactivated after 5 days without a scenario. Check its status under **Webhooks**.
> * The queue is full. Check the **Queue** tab and raise **Maximum number of results** or run more often.
> * An event filter in ClickFlare blocks the event.

> [accordion] New fields from ClickFlare don't show up in Make
>
> Make still uses the old data structure. Click **Redetermine data structure** on the Custom webhook module and fire a new event.

> [accordion] The POST to ClickFlare runs but no conversion appears
>
> * `cf_click_id` is empty or isn't a ClickFlare click ID.
> * `ct` doesn't match a custom conversion exactly.
> * The URL isn't your tracking domain with `/cf/cv`, or the body type isn't application/JSON.
> * With **JSON string**, the body is invalid: a quote inside a value broke it. Switch to **Data structure**.
>
> See [Troubleshooting S2S postbacks](/docs/en/tracking/troubleshooting-s2s-postback-url-in-clickflare.md).

> [accordion] The API returns 401
>
> The `api-key` header is missing or wrong. Check the keychain's placement and parameter name, and that the key still exists in ClickFlare.

***

## FAQ

> [accordion] Does ClickFlare integrate with Make?
>
> Yes, both ways. ClickFlare's Custom Webhook starts Make scenarios, and Make's HTTP app posts conversions to ClickFlare's /cf/cv as JSON or calls the REST API.

> [accordion] Do ClickFlare events run the scenario right away?
>
> Yes, by default. If you schedule the scenario, events wait in the webhook's queue until the next run.

> [accordion] Can each campaign go to a different scenario?
>
> Yes. Set up the webhook on the campaign itself so each campaign fires to its own Make URL. See [Custom Webhook](/docs/en/integrations/custom-webhook-integration.md).

> [accordion] GET or POST?
>
> POST with JSON for most cases. Both carry the same values, `txid` included. Use GET if the target app only offers a URL.

***

## Related

> [card] [Custom Webhook](/docs/en/integrations/custom-webhook-integration.md)
>
> Send any event out

> [card] [n8n](/docs/en/integrations/n8n-click-flare-integration-guide.md)
>
> The same with n8n

> [card] [API overview](/docs/en/api/clickflare-api-overview.md)
>
> Keys and endpoints


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.