Integrations

The screen is simple: a tab strip on top, and under each tab a table plus an add/edit modal. Five tabs: Ad networks · Facebook · TikTok · Google · Postback 2.0.

The tab strip and when each tab shows

The "Ad networks" tab is always there — cost accounting is core to the tracker, not a hack. The other four are separate hacks, and a tab only appears when its hack is active on your account (hacks.<name>). No fbpix hack, no Facebook tab. On the demo stand all four are on, so you see the full five.

• The bare /app/integrations address redirects itself to /integrations/advnets — so Ad networks is the default landing tab.
• Each tab has a Scope: Mine / Team switch on top. In team mode the screen shows the whole team's integrations; only team admins can edit them (a regular member sees the edit controls disabled).

Tab 1 — Ad networks (cost connectors)

A connector is a little robot that visits the ad network's API, fetches your spend and writes the price onto each click in the tracker. From then on Reports and Sources compute ROI from real money, not from what you happen to remember.

Toolbar: Add connector · Request log.

Table columns:

• Name — what you called the connector (e.g. "Spend import — main network").
• Active — an inline toggle checkbox right in the row (turns import on/off).
• Network — the connector type (which ad network).
• Last check — when the robot last fetched spend.
• Next check — when it goes again (per schedule).
• Actions: Edit · Run import · Request log · Delete.

Connector types (11 in Lite): facebook, tiktok, bigo, dolphin, dolphincl, fbtool, mgid, mixadvert, adpartner, luckyads, vk. The tracker builds the type list itself — if a new connector ships in the build, it shows up in the dropdown with no UI change.

Workflow — add a cost connector, run it, inspect the log

Adding a connector is two-step — first create the row, then configure it. There's no other way: a connector has no fields until you've picked its type.

1. Click "Add connector".
2. Enter a name and pick a network. In the small modal enter a Name and pick a Network (type) from the list (facebook, tiktok, bigo, …). Click Create.
3. The row is created — and the editor opens immediately for that connector.
4. Fill the editor (top to bottom):
   • Connector help — a hint block for that specific network (which credentials it needs).
   • Status — an "active" checkbox.
   • Name.
   • Access — only the auth fields this network needs (some want a token, some a login/password, some a URL + key). We don't show fields it doesn't use.
   • Schedule — repeat (6 options: daily / hourly / every 3h / twice a day / three times a day / every 3 days) and period (5 options: today / yesterday / today+yesterday / 3 days / week), plus the Unique and Valid checkboxes.
   • Filter — Source (restrict the import to a single utm_source value) and Field (which UTM tag carries the creative/ad id — chosen from a list of tags, not typed).
   • Connector extras — network-specific settings (facebook, for example, adds a mode + proxy).
5. Click "Save".
6. Run the import by hand. Don't want to wait for the schedule? In the connector's row hit Run import and confirm. The robot visits the network and writes click prices now.
7. Check the request log. To confirm the robot went through, open the Request log.

Connector request log

Opened via Request log (from the toolbar or a connector row). It's a drawer listing every call the robot made to the networks' APIs, 50 per page. Filters up top:

• Connector — show the log for one specific connector.
• Result — filter by error type (or show only the successful calls).
• ↻ Refresh.

Each row expands — inside is the full request and response: URL, POST body, GET params, the network's reply, headers, HTTP status and timer. This is where you go when "the import didn't work" — you can see exactly what the network answered.

Tab 2 — Facebook (fbpix, Conversions API)

The Facebook pixel fires events to the Conversions API when a lead changes status. The tab is a table of pixels plus a settings modal.

Table columns: Name · Active · Pixel · Lead field · New · Domain.

Modal fields (13):

• Name — the pixel's name (doubles as the comment).
• Pixel * — the numeric pixel id. Required.
• Lead field * — which lead tag carries the value (picked from tags). Required.
• Value — a reference value.
• New / Hold / Approve — FB event names per status (picked from an events list, can be left empty).
• Send lead data — a checkbox (whether to send lead PII).
• No click — a checkbox.
• Domain.
• Proxy.
• Goals — a multiselect over your goals.
• Access token * — required.

The minimum to save at all: Pixel + Lead field + Access token.

Tab 3 — TikTok (ttpix)

Almost a carbon copy of Facebook — same idea, same field set, with exactly two differences:

• The pixel is a string here, not a number (a TikTok code like TTPIXCODE999, not bare digits).
• No "Send lead data" and no "No click" fields — TikTok simply doesn't have them.

So the modal has 11 fields instead of 13. Everything else — Name, Lead field, Value, New/Hold/Approve, Domain, Proxy, Goals, Access token — is identical to Facebook. The required minimum is the same in spirit: Pixel + Lead field + Access token.

Tab 4 — Google (gclid, offline conversions)

This isn't a "live" pixel but a builder of an offline-conversions document per campaign — the doc Google pulls conversions from by gclid. So Google has no "Active" toggle (there's nothing to switch — the doc either exists or not) and the record is addressed differently under the hood (doc, not pb).

Table columns: Name · Bound tag · Domain · Countries · Progress.

Modal fields (14, under two group headers — "UTM override" and "Scope and windows"):

• Name * — required.
• Bound tag * — which tag carries the gclid (picked from tags). Required.
• Domain * — the parked domain the export URL is built from. Required.
• Countries — country codes.
• UTM ×6 — override the utm tags (source/campaign/content/term/medium/domain).
• Streams — restrict to streams (a list of ids).
• Trash / Cancel / Lead — status windows and settings.

The required minimum: Name + Bound tag + Domain.

Tab 5 — Postback 2.0 (p2b, outbound builder)

This is a builder of outbound postbacks/webhooks: the tracker knocks on your URL when a lead changes status. Say, "Postback to the cats' Telegram".

Table columns: Name · Active · Channel · Filter by lead field · Value.

Modal fields under three group headers:

• Events — flags for which statuses to send on: Global · New · Hold · Approve · Cancel · Trash.
• Request body — URL * (required), the POST method, format, headers; plus Async (send asynchronously) and Nolog (don't write to the log) checkboxes.
• Authorization — a handshake toggle. While it's off, the block is empty. Turn it on and extra fields appear: Auth URL · Auth body · Auth format · Auth headers · Token path · Token TTL. Turn it off and they hide again.

The required minimum: Name + URL. If the channel needs POST (type 1) you'll also need body and headers.

Shared moves across all five tabs

All four pixel tabs (Facebook, TikTok, Google, Postback) work the same way — a table plus an add/edit modal. Each row has the same action set:

• Toggle "Active" — inline, one click (Google has none — no status there).
• Edit — opens the modal. The modal re-fetches the full record (e.g. to pull the token, which isn't in the list).
• Clone — asks for a new name (no name, no clone).
• Delete — confirm-gated.

Workflow 1 — add a pixel (Facebook as the example)

1. Open the Facebook tab.
2. Click + Add (an empty list will prompt "Add your first integration").
3. Fill the modal: Pixel (number), Lead field, Access token — that's the minimum, the rest to taste (New/Hold/Approve events, domain, goals).
4. Click "Save" → toast "Created".
5. The new row appears in the table.

Workflow 2 — switch an integration on/off with the checkbox

1. Find the row in the table.
2. Click the toggle in the Active column.
3. Done — the state saves immediately, no modal needed.

Good to know (the gotchas)

• Google is the odd one out. It has no "Active", and its record is addressed as doc rather than the others' pb. For you that means one thing: don't look for a Google toggle — it isn't there by design.
• Connectors' "Run import" really spends and changes prices. Once more, because it matters: it's not a test. The confirm gate is there for a reason.
• Reference lookups (events / tags / goals) are per scope. Goals depend on the owner, so switching Mine ↔ Team reloads the lists. Don't be surprised the goal set differs in team mode.
• Clone wants a name. A copy won't be created without a new name — that's protection against nameless dupes.
• The pagination is "object-shaped". Technically the four pixels return data not as a flat list but as a keyed object — you only ever see a normal paged table (50 per page), but know that it's the same screen, just wired differently underneath.
• Connector headings may be in English — see above, that's the server's locale, not a broken translation.

Coming from your old tracker

This is where everything your old tracker spread across pixels, postbacks and cost integrations lives. The Facebook/TikTok pixels and Google conversions are your S2S/pixel settings; Postback 2.0 is your outbound postback builder; "Ad networks" are the cost integrations that pull spend so ROI is counted from real money. Same wires — just labelled in familiar words, and with no separate price tag on the interface.