Admitad

Datafly Signal reports affiliate conversions to the Admitad (Mitgo) partner network server-to-server. Instead of a browser tracking pixel on your confirmation page, Signal sends a trusted backend postback to Admitad’s tracking endpoint, attributed by the admitad_uid captured when the user clicked the affiliate link. This delivers conversions reliably even when the browser pixel is blocked by ad blockers or tracking prevention.

Prerequisites

Before configuring Admitad in Signal you need an active Admitad advertiser program and its integration credentials.

Step 1: Open your program’s integration settings

Sign in to your Admitad advertiser account.
Go to Integration > Integration methods > Custom integration > Postback.

Step 2: Note your Campaign Code and Postback Key

Copy the campaign_code for your program.
Copy the Postback Key — this is the private security key that authenticates server-side requests. Treat it like a password.

Step 3: Note the Action and Tariff codes

In the Postback table, each target action (purchase, registration, lead) has:

an action_code (the Action column), and
a tariff_code (the Rate column).

Note the pair for each action you want to track. A program that only pays for sales needs just the sale codes.

Step 4: Confirm admitad_uid capture

Admitad sets the admitad_uid cookie in the visitor’s browser when they arrive via an affiliate link. Signal’s collector must read this cookie and persist it so it can be replayed on the conversion. Without a valid admitad_uid, Admitad cannot attribute the conversion to a publisher and the commission is lost.

Configure in Signal

Configuration Fields

Field	Required	Description
`campaign_code`	Yes	Your Admitad program/campaign identifier.
`postback_key`	Yes	The private security key from the Postback settings. Stored as a secret.
`sale_action_code`	Yes	Action code for purchases (Order Completed).
`sale_tariff_code`	Yes	Tariff/rate code for purchases.
`registration_action_code`	No	Action code for registrations (Signed Up).
`registration_tariff_code`	No	Tariff/rate code for registrations.
`lead_action_code`	No	Action code for leads (Lead Generated).
`lead_tariff_code`	No	Tariff/rate code for leads.

Management UI Setup

Go to Integrations > Add Integration > Admitad.
Enter your campaign_code and postback_key.
Enter the action_code / tariff_code pairs for each conversion type you track.
Select consent categories (typically advertising or marketing).
Click Save.

API Endpoint

GET https://ad.admitad.com/tt?postback=1&postback_key={postback_key}&campaign_code={campaign_code}&response_type=json&...

All conversion data travels in the URL query string — there is no JSON body. The postback=1 flag marks the request as a trusted server-side postback, and response_type=json returns a JSON status body. Signal URL-encodes every parameter.

Admitad also serves the same endpoint through mirror hosts (for ad-blocker resilience). Signal uses the canonical ad.admitad.com host for server-to-server delivery, which is the correct choice for a backend postback.

Identity Signals

Admitad attribution is deterministic and keyed on a single click identifier.

Signal	Parameter	Description
`admitad_uid`	`uid`	The Admitad unique click ID. Set as a cookie when the user clicks an affiliate link; Signal persists it and replays it on the conversion. Required — without it the conversion is not attributed.
Customer ID	`client_id`	Your internal user/customer ID, used by Admitad for new-vs-returning customer logic.
Channel	`channel`	Traffic channel label, sourced from the campaign source.

⚠️

No PII (email, phone, name) is sent to Admitad. Affiliate attribution relies solely on the admitad_uid click identifier, so there is nothing to hash.

Event Mapping

The Default preset maps three Signal events to Admitad target actions:

Signal event	Admitad action	Parameters
`Order Completed`	sale	`order_id`, `price`, `currency_code`, `promocode`, `product_id`, `quantity`
`Signed Up`	registration	`order_id`, action/tariff codes
`Lead Generated`	lead	`order_id`, `price`, `currency_code`

The action_code and tariff_code for each event come from your integration config, so the same blueprint works for any Admitad program.

Example: Sale Conversion

Datafly.js call:

datafly.track("Order Completed", {
  order_id: "ORD-1001",
  revenue: 129.99,
  currency: "GBP",
  coupon: "SUMMER10",
  product_id: "SKU-A",
  quantity: 2
});

Admitad request sent by Signal:

GET https://ad.admitad.com/tt
  ?postback=1
  &postback_key=••••••••
  &campaign_code=abc123def456
  &response_type=json
  &uid=2f1c8a9e-...            (admitad_uid from the affiliate-link click)
  &order_id=ORD-1001
  &price=129.99
  &currency_code=GBP
  &promocode=SUMMER10
  &product_id=SKU-A
  &quantity=2
  &action_code=1
  &tariff_code=1
  &payment_type=sale
  &client_id=user-123

Testing

Click one of your live affiliate links so Admitad sets the admitad_uid cookie, then complete a test conversion on your site.
In your Admitad advertiser account, open the Statistics / Actions report. The test action appears with an unconfirmed status shortly after delivery.
Use Signal’s Event Debugger to inspect the outgoing request and confirm uid, order_id, action_code, and tariff_code are populated.

New actions arrive in Admitad as “not confirmed” until you validate them in the advertiser dashboard. This is expected — it does not mean the postback failed.

Troubleshooting

Problem	Solution
Conversions not appearing in Admitad	Confirm `uid` (admitad_uid) is present on the request. If the user did not arrive via an affiliate link, there is no uid and Admitad correctly ignores the conversion.
`403` / rejected requests	The `postback_key` is wrong or the program is disabled. Re-copy the key from Integration > Custom integration > Postback.
`404` responses	The `campaign_code` does not match an active program.
Wrong commission / action type	Check the `action_code` and `tariff_code` pairs match the Action and Rate columns in your Admitad Postback settings.
Duplicate conversions	Ensure `order_id` is unique per order; Admitad deduplicates on the order identifier.

Webgains Effinity