Talon.One

Datafly Signal delivers events to Talon.One server-to-server using the Integration API (the Track Event V2 endpoint). Events arrive as Talon.One custom events and are evaluated by the Rule Engine to drive promotions, coupons, loyalty, and referral campaigns — with no client-side Talon.One SDK on your pages.

Why route Talon.One through Datafly Signal

Profiles are updated from the server, not the browser. Events reach Talon.One even when a tracker blocker or a failed page unload would have dropped a client-side call, so the profile reflects what actually happened.
One consent decision governs every destination. Talon.One is gated by the same consent state as the rest of your stack, so a withdrawal applies everywhere at once.

Prerequisites

Before configuring Talon.One in Signal you need a Talon.One Application, its deployment host, and a Production Integration API key.

Note your deployment host

Your Talon.One account lives on a region-specific host such as mycompany.europe-west1.talon.one. This is the host portion of the URL you use to reach the Campaign Manager. Signal posts events to https://<deployment>/v2/events.

Create the custom events

The Track Event V2 endpoint only accepts events whose type has been declared in the Campaign Manager. For each event you intend to send:

In the Campaign Manager, open your Application > Settings > Developer settings (custom attributes and events).
Create a custom event for each type this blueprint sends: pageview, signed_up, logged_in, product_viewed, product_added, checkout_started, order_completed, order_refunded.
Create a custom attribute (on the event or profile, with the correct data type) for every attribute key you intend to use — for example productId (string), price (number), total (number), currency (string), couponCode (string).

⚠️

Talon.One rejects events whose type is not declared, and rejects attributes that are missing or have the wrong data type, with a 400 response. Declare every event and attribute before going live.

Generate an Integration API key

In your Application, go to Settings > Integration API Keys.
Click Create API Key.
Select Production as the key type, give it a name (e.g. “Datafly Signal”), and set an expiration date.
Copy the key — Signal sends it as Authorization: ApiKey-v1 <key>.

Use an Integration API key, not a Management API key. The two are different credentials with different scopes.

Configure in Signal

Configuration Fields

Field	Required	Description
`deployment`	Yes	Your Talon.One deployment host without the scheme, e.g. `mycompany.europe-west1.talon.one`.
`api_key`	Yes	A Production Integration API key. Sent as `Authorization: ApiKey-v1 <key>`.

Management UI Setup

Go to Integrations > Add Integration > Talon.One.
Choose the Default preset.
Enter your deployment host and api_key.
Select the consent categories that should gate delivery (typically marketing).
Click Save.

API Endpoint

POST https://<deployment>/v2/events
Authorization: ApiKey-v1 <api_key>
Content-Type: application/json

The request body carries a required profileId, the custom event type, and an attributes object:

{
  "profileId": "user-123",
  "type": "product_viewed",
  "attributes": {
    "productId": "SKU-A",
    "price": 49.99,
    "currency": "USD"
  }
}

If the profileId is new, Talon.One creates the customer profile automatically.

Identity Signals

Talon.One identifies customers by profile. Signal sends only known customers:

Signal	Talon.One field	Description
`user_id`	`profileId`	Your stable customer identifier: the key Talon.One attaches loyalty balances, coupons and referral state to. Events without a `user_id` are not sent, so no guest profile is created per anonymous visitor.

No email address or consent flag is sent as an event attribute: set customer profile attributes in Talon.One from your own systems.

Call datafly.identify() when a user logs in or registers so a stable user_id flows into profileId:

datafly.identify("user-123");

Event Mapping

Default preset

Signal event	Talon.One event `type`	Attributes
`page`	`pageview`	Off by default: every event is a billed Integration API call.
`sign_up`	`signed_up`	`method`
`login`	`logged_in`	`method`
`view_item`	`product_viewed`	`productId`, `productName`, `category`
`add_to_cart`	`product_added`	`productId`, `productName`, `value`, `currency`
`begin_checkout`	`checkout_started`	`value`, `currency`, `couponCode`, `itemIds`
`purchase`	`order_completed`	`orderId`, `total`, `currency`, `tax`, `shipping`, `couponCode`, `itemIds`
`refund`	`order_refunded`	`orderId`, `total`, `currency`, `itemIds`

itemIds is a list of strings (the items[].item_id values): Talon.One custom attributes are scalars or lists of scalars, so an array of item objects cannot be sent. Create each event type and attribute, with matching types, in the Campaign Manager before enabling the integration.

⚠️

These are custom events. They do not create, update or close customer sessions, so they apply no cart discounts, redeem no coupons and do not trigger rules on built-in session events. Use them for rules on custom events: loyalty points, referrals, achievements, or coupons issued by a rule. If your storefront already closes a session for each order, do not also award order loyalty on order_completed, or the customer is credited twice.

Events not in the mapping are dropped. To customise, edit the integration’s Field Mappings in the Management UI.

Example: Order Completed

Datafly.js call:

datafly.track("purchase", {
  transaction_id: "ORD-1001",
  value: 279.98,
  currency: "gbp",
  tax: 46.66,
  shipping: 4.99,
  coupon: "SPRING10",
  items: [
    { item_id: "SKU-1", item_name: "Parka Jacket", price: 129.99, quantity: 2 },
    { item_id: "SKU-2", item_name: "Wool Hat", price: 20, quantity: 1 }
  ]
});

Talon.One payload sent by Signal:

{
  "profileId": "crm-user-7",
  "type": "order_completed",
  "attributes": {
    "orderId": "ORD-1001",
    "total": 279.98,
    "currency": "GBP",
    "tax": 46.66,
    "shipping": 4.99,
    "couponCode": "SPRING10",
    "itemIds": ["SKU-1", "SKU-2"]
  }
}

Testing

Send a test event

Trigger an event on a page where Datafly.js is installed (for example a product page for product_viewed).

Verify in the Campaign Manager

Open your Application and go to the customer profile for the profileId you sent (or search by it).
Confirm the event appears in the profile’s activity, with the attributes you mapped.
If you have a rule listening for that custom event, confirm the expected effect (coupon, loyalty points, etc.) was applied.

Use the event debugger

Use Signal’s Event Debugger to inspect the exact JSON body Signal sent and the HTTP response code from Talon.One.

Troubleshooting

Problem	Solution
`400 Bad Request`	The custom event `type` or one of the attributes is not declared in the Campaign Manager, or an attribute has the wrong data type. Declare/correct it under Developer settings.
`401 Unauthorized`	The Integration API key is wrong, expired, or you used a Management API key. Generate a new Production Integration API key.
`404 Not Found`	The `deployment` host is wrong. Confirm the region subdomain (e.g. `europe-west1`).
Events accepted but no rule fires	Confirm a campaign rule is listening for that custom event `type`, and that the profile/session has the attributes the rule checks.
Events not arriving for some visitors	Only identified visitors are sent. Ensure `datafly.identify()` is called so a `user_id` is present.

Chameleon Session AI