# SKUs


The read-only catalogs for the `SKUs` dataset on
[Create Audience](/api/v2/audiences#post-apiv2analysesaudiencescreate): the
merchants, the product brands, the product categories and the purchase-device
values a `SKUs` block can name. Two more reads describe the data itself: its
[coverage](#get-apiv2analysesreferenceskuscoverage) and its
[insights](#get-apiv2analysesreferenceskusinsights), the brands, merchants,
and categories with the most orders. The dataset is available on request.

Every read here is authenticated and JSON-only (bearer token + `Accept:
application/json`) and uses the read rate bucket (120 requests/min per caller).
An account without the `SKUs` dataset reads every one of them empty.

An organization billed in credits cannot build or schedule a `SKUs` audience
until the dataset has a credit price: the request gets a `422` whose
`data.error` is `dataset_not_priced` and whose `data.dataset_types` lists
`SKUs`. Ask your account manager. An estimate is still answered, and
[Quote Audience](/api/v2/audiences#post-apiv2analysesaudiencesquote) answers
`422` "This run cannot be priced in credits yet. Contact your Account Manager."
until then.

## What the data is {#what-the-data-is}

A `SKUs` audience holds the devices seen on the home networks that the
purchases of a product brand, or the purchases from a merchant, in a period
came from.

The data is online purchases at product level. Each order line names the
merchant, the product brand, and the day of the purchase. It comes from a panel
of affiliate-tracked orders: the purchases that started with a tracked click,
not every purchase a merchant made. Coverage is strongest at large United
States retailers, and most of the orders are in the United States. Returns are
left out.

The audience holds the devices seen on the home network the purchase click came
from. An order with no tracked click has no network, so it adds no device and it
has no country.

Treat the counts as a panel, not as a merchant's sales. Use
[Estimate Audience Size](/api/v2/audiences#post-apiv2analysesaudiencesestimate)
to size a brand or a merchant before you build. A `SKUs` estimate is always
answered by a worker, so it takes longer than a fast answer.

## Coverage and freshness {#coverage}

Purchases start on 2026-07-30 and load once a day. A purchase day keeps filling
for about three days: most of its orders arrive by the second daily load and
nearly all by the third, so the two newest days read low.

Some days before 2026-10-01 hold no or few purchases, and
[Get SKUs Coverage](#get-apiv2analysesreferenceskuscoverage) lists them
(`empty_days`, `thin_days`). A period that includes any of those days holds
fewer purchases. From 2026-10-01 every day has purchases.

The devices seen on a home network are refreshed once a day. A purchase click
newer than the last refresh adds no device until the next one, and a purchase
day gains devices for about a week, so an audience over the most recent days
holds fewer devices than the same audience built a week later.

## Match Strictness {#match-strictness}

`max_devices_per_ip` sets how closely a device must match the home network of
the purchase click. It is a level from `1` to `5`, and `3` is the default.

| Level | Name | What it keeps |
| --- | --- | --- |
| `1` | Very Strict | The fewest devices: those seen on the network on the day of the click and around it, on networks with few devices. |
| `2` | Strict | Between levels 1 and 3. |
| `3` | Recommended | The default. |
| `4` | Moderate | Between levels 3 and 5. |
| `5` | More Reach | Every device seen on that network, so the most devices, including shared networks. |

A stricter level keeps the devices seen on the network on the day of the click,
on more days around it, and on networks with few devices. A wider level adds
devices seen on the network only near that day, and networks with many devices,
such as shared networks. Choose a low level for precision and a high level for
reach.

## Spend filters {#spend-filters}

Seven optional keys on a `SKUs` block keep the home networks, or the purchase
lines, by what was spent. Amounts are in USD as delivered by the panel, and a
handful of non-US lines may carry local prices.

| Key | What it does |
| --- | --- |
| `item_price_min`, `item_price_max` | The price of one purchased item, 0 to 1,000,000,000. A filter on each purchase line: a line outside the range is left out before anything else is counted. |
| `spend_min`, `spend_max` | What a home network spent across its matched purchase lines in the window, 0 to 1,000,000,000. |
| `orders_min`, `orders_max` | The orders of that home network in the window (orders with a matched purchase line), whole numbers from 1 to 1,000,000. |
| `spend_top_percent` | `50`, `25`, `10`, `5` or `1`. Ranks every home network with a matched purchase by spend and keeps the top share. |

- **Min and max.** A minimum above its maximum is refused with `422`, for each
  of the three pairs.
- **Top spenders.** Ties at the cut are kept, so a network tied with the last
  network inside the share is kept too. The rank is computed before the
  `spend_*` and `orders_*` bounds, so "Top 10%" means the same with or without
  other bounds. An order with no tracked click has no home network, so it is not ranked and does not count in the share.
- **Other dataset types.** Each key is refused with `422` on any other dataset
  type. The exception is `spend_min` and `spend_max`, which
  `AffinityTransactions` already accepts with its own meaning.
- **Key lists.** The lists `merchants`, `brands`, `device_types`,
  `device_oses`, `device_makes` and `device_models` share a size budget. Setting
  a spend, orders or top spenders key halves it, and a list that no longer fits
  is refused with `422`: choose fewer keys.

The buyers of Dry Dog Food (category `10000000`) in the top 10% by spend, who
placed at least two orders:

```json
{
  "type": "SKUs",
  "start_date": "2026-10-01",
  "end_date": "2026-10-31",
  "categories": [10000000],
  "location": { "countries": ["USA"] },
  "spend_top_percent": 10,
  "orders_min": 2
}
```

## Combining a SKUs dataset {#combining}

A `SKUs` dataset is built alone, or with one other dataset and an `operator`
(`AND`, `OR`, or `NOTIN`). The other dataset is a `POI`, `Apps`, `WebDomain`,
`CTV`, `ProfileAttributes`, or `AffinityTransactions` dataset, or a second `SKUs`
dataset, in either position. Any other type is refused with a `422` on its
`datasets.<i>.type`.

An audience with a `SKUs` dataset runs no analysis and no refine. A
`crossvisitation`, `crosspurchase` or `networkswitching` block, an `analyses`
flag, the `analysis_spend_frequency` and `analysis_transactions_frequency`
flags of an `AffinityTransactions` dataset, and a `refine` block on the other
dataset are each refused with a `422` on their own key.

## Get SKUs Merchants {#get-apiv2analysesreferenceskusmerchants}

`GET /api/v2/analyses/reference/skus/merchants`

The merchants a `SKUs` dataset can name in `merchants`. A flat list, with the
merchants that had the most orders in the last 90 days first.

**Auth:** bearer token + `Accept: application/json`. Rate limit: read bucket
(120 requests/min).

### Query parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `search` | string | No | Optional free-text filter on the merchant name (case-insensitive contains). |

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/skus/merchants?search=outdoor" \
    -H "Authorization: Bearer <YOUR_TOKEN>" \
    -H "Accept: application/json"
  ```
  {{< /tab >}}

  {{< tab name="Python" >}}
  ```python
  import requests

  res = requests.get(
      "https://console.intuizi.com/api/v2/analyses/reference/skus/merchants",
      params={"search": "outdoor"},
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
  )
  merchants = [row["value"] for row in res.json()["data"]]
  ```
  {{< /tab >}}

  {{< tab name="JavaScript" >}}
  ```javascript
  const res = await fetch(
    "https://console.intuizi.com/api/v2/analyses/reference/skus/merchants?search=outdoor",
    { headers: { Authorization: "Bearer <YOUR_TOKEN>", Accept: "application/json" } }
  );
  const merchants = (await res.json()).data.map((row) => row.value);
  ```
  {{< /tab >}}

  {{< tab name="PHP" >}}
  ```php
  $res = Http::withToken('<YOUR_TOKEN>')->acceptJson()
      ->get('https://console.intuizi.com/api/v2/analyses/reference/skus/merchants', [
          'search' => 'outdoor',
      ]);
  $merchants = collect($res->json('data'))->pluck('value');
  ```
  {{< /tab >}}

{{< /tabs >}}

### Response

Each item has a `value` (the merchant key to put in `merchants`) and a `text`
label (the merchant name). Send the `value`, never the `text`: a key is matched
exactly.

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "value": "example outdoor store", "text": "Example Outdoor Store" },
    { "value": "example outdoor outlet", "text": "Example Outdoor Outlet" }
  ]
}
```

## Get SKUs Brands {#get-apiv2analysesreferenceskusbrands}

`GET /api/v2/analyses/reference/skus/brands`

The product brands a `SKUs` dataset can name in `brands`. The catalog is large,
so the list is paginated and you find a brand with `search`. Without a search
the brands that had the most orders in the last 90 days come first. With one,
the names that start with it come first, then the names that contain it.

**Auth:** bearer token + `Accept: application/json`. Rate limit: read bucket
(120 requests/min).

### Query parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `search` | string | No | Optional free-text filter on the brand name (case-insensitive contains). |
| `page` | integer | No | Page number, starting at 1. |
| `per_page` | integer | No | Items per page, up to 500 (default 100). |
| `categories` | string | No | Comma-separated category ids: only the brands with orders under at least one of them (see [Get SKUs Categories](#get-apiv2analysesreferenceskuscategories)). |

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/skus/brands?search=dove&per_page=25" \
    -H "Authorization: Bearer <YOUR_TOKEN>" \
    -H "Accept: application/json"
  ```
  {{< /tab >}}

  {{< tab name="Python" >}}
  ```python
  import requests

  res = requests.get(
      "https://console.intuizi.com/api/v2/analyses/reference/skus/brands",
      params={"search": "dove", "per_page": 25},
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
  )
  brands = [row["value"] for row in res.json()["data"]["items"]]
  ```
  {{< /tab >}}

  {{< tab name="JavaScript" >}}
  ```javascript
  const res = await fetch(
    "https://console.intuizi.com/api/v2/analyses/reference/skus/brands?search=dove&per_page=25",
    { headers: { Authorization: "Bearer <YOUR_TOKEN>", Accept: "application/json" } }
  );
  const brands = (await res.json()).data.items.map((row) => row.value);
  ```
  {{< /tab >}}

  {{< tab name="PHP" >}}
  ```php
  $res = Http::withToken('<YOUR_TOKEN>')->acceptJson()
      ->get('https://console.intuizi.com/api/v2/analyses/reference/skus/brands', [
          'search' => 'dove',
          'per_page' => 25,
      ]);
  $brands = collect($res->json('data.items'))->pluck('value');
  ```
  {{< /tab >}}

{{< /tabs >}}

### Response

Each item has a `value` (the brand key to put in `brands`) and a `text` label
(the brand name). Send the `value`, never the `text`: a key is matched exactly.

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": {
    "items": [
      { "value": "dove", "text": "Dove" },
      { "value": "dove men+care", "text": "Dove Men+Care" },
      { "value": "baby dove", "text": "Baby Dove" }
    ],
    "pagination": { "current_page": 1, "per_page": 25, "total": 3, "last_page": 1 }
  }
}
```

## Get SKUs Categories {#get-apiv2analysesreferenceskuscategories}

`GET /api/v2/analyses/reference/skus/categories`

The product categories a `SKUs` dataset can name in `categories`: the Google
Product Taxonomy (version 2021-09-21) with finer levels of our own where the
data has them, such as Dry Dog Food and Wet Dog Food under Non-prescription Dog
Food. Each order line has one category. A category selects itself and every
category under it, so Dog Food includes Dry Dog Food.

Without a search the read lists the children of `parent_id` (the top level when
you leave it out) that had orders in the last 90 days, the most orders first:
walk the tree one level at a time. With a search it lists the categories of any
level whose name contains it (at most 100). A category id never changes its
meaning and is never reused, so a saved audience keeps building on it.
Retired and sensitive categories are not offered: the read never lists them,
and a `SKUs` block cannot name them.

**Auth:** bearer token + `Accept: application/json`. Rate limit: read bucket
(120 requests/min).

### Query parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `parent_id` | integer | No | List the children of this category. Left out: the top level. |
| `search` | string | No | Optional free-text filter on the category name (case-insensitive contains), any level. |

```bash
curl "https://console.intuizi.com/api/v2/analyses/reference/skus/categories?parent_id=3530" \
  -H "Authorization: Bearer <YOUR_TOKEN>" \
  -H "Accept: application/json"
```

### Response

Each item has a `value` (the category id to put in `categories`), a `text`
label (the name), its full `path`, `parent_id`, `level`, `has_children` and
`orders` (the orders of the last 90 days under it).

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "value": 543682, "text": "Non-prescription Dog Food", "path": "Animals & Pet Supplies > Pet Supplies > Dog Supplies > Dog Food > Non-prescription Dog Food", "parent_id": 3530, "level": 5, "has_children": true, "orders": 15210 }
  ]
}
```

## Get SKUs Device Values {#get-apiv2analysesreferenceskusdevice-values}

`GET /api/v2/analyses/reference/skus/device-values`

The values a `SKUs` dataset can name for the device of the purchase click:
`field=type` for `device_types`, `os` for `device_oses`, `make` for
`device_makes` and `model` for `device_models`. Each item has `value` and
`text`, both the value as the dataset holds it (upper case, such as `IOS` or
`APPLE`). Send the `value` exactly. These filter the orders by the device that
made the purchase; the audience is still every device seen on that home network.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `field` | string | Yes | One of `type`, `os`, `make`, `model`. |
| `search` | string | No | Optional free-text filter (case-insensitive contains), useful for models. |

```bash
curl "https://console.intuizi.com/api/v2/analyses/reference/skus/device-values?field=os" \
  -H "Authorization: Bearer <YOUR_TOKEN>" \
  -H "Accept: application/json"
```

## Get SKUs Coverage {#get-apiv2analysesreferenceskuscoverage}

`GET /api/v2/analyses/reference/skus/coverage`

What the `SKUs` data covers: the first and the newest purchase day, the newest
day whose purchases have settled, the newest purchase-click day with devices,
and the days with no or few purchases. Read it before you pick the dates of a
`SKUs` block: a period with empty or thin days, or one that ends after the
settled day or the device day, holds fewer purchases or fewer devices. The list
holds one item, updated once a day. It is an empty list until the first daily
update has run, and for an account without the `SKUs` dataset.

**Auth:** bearer token + `Accept: application/json`. Rate limit: read bucket
(120 requests/min).

This read takes no query parameters. The coverage read takes no `search`,
`page`, or `per_page`, which most reference reads take, and refuses each of
them. Any other parameter is refused with a `422` that names it.

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/skus/coverage" \
    -H "Authorization: Bearer <YOUR_TOKEN>" \
    -H "Accept: application/json"
  ```
  {{< /tab >}}

  {{< tab name="Python" >}}
  ```python
  import requests

  res = requests.get(
      "https://console.intuizi.com/api/v2/analyses/reference/skus/coverage",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
  )
  items = res.json()["data"]
  coverage = items[0] if items else None
  ```
  {{< /tab >}}

  {{< tab name="JavaScript" >}}
  ```javascript
  const res = await fetch(
    "https://console.intuizi.com/api/v2/analyses/reference/skus/coverage",
    { headers: { Authorization: "Bearer <YOUR_TOKEN>", Accept: "application/json" } }
  );
  const [coverage = null] = (await res.json()).data;
  ```
  {{< /tab >}}

  {{< tab name="PHP" >}}
  ```php
  $res = Http::withToken('<YOUR_TOKEN>')->acceptJson()
      ->get('https://console.intuizi.com/api/v2/analyses/reference/skus/coverage');
  $coverage = $res->json('data.0');
  ```
  {{< /tab >}}

{{< /tabs >}}

### Response

| Field | Type | Description |
| --- | --- | --- |
| `first_day` | string | The first day with purchases, `YYYY-MM-DD`. |
| `newest_purchase_day` | string | The newest day with purchases loaded. |
| `settled_day` | string | Two days before `newest_purchase_day`. A purchase day keeps filling for about three days, so the days after `settled_day` still read low. |
| `newest_device_day` | string or null | The newest purchase-click day whose devices are in. A purchase clicked after it adds no device yet. `null` before the first device refresh. |
| `empty_days` | array | The days with no purchases between `first_day` and `settled_day`, as `[first, last]` ranges, both days included. |
| `thin_days` | array | The days in that span that have purchases, but fewer than 10% of the median of the days with purchases within 7 days of them. |
| `computed_at` | string | When the item was computed, in UTC (`YYYY-MM-DDTHH:MM:SSZ`). |

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    {
      "first_day": "2026-07-30",
      "newest_purchase_day": "2026-11-12",
      "settled_day": "2026-11-10",
      "newest_device_day": "2026-11-08",
      "empty_days": [["2026-08-01", "2026-08-02"], ["2026-08-15", "2026-08-27"], ["2026-09-14", "2026-09-26"]],
      "thin_days": ["2026-07-31", "2026-08-14", "2026-08-30", "2026-08-31", "2026-09-13", "2026-09-29", "2026-09-30"],
      "computed_at": "2026-11-13T21:04:37Z"
    }
  ]
}
```

## Get SKUs Insights {#get-apiv2analysesreferenceskusinsights}

`GET /api/v2/analyses/reference/skus/insights`

What sells in the `SKUs` data: the product brands, the merchants, or the
product categories with the most orders over the last 7, 30, or 90 days, with
their spend, home networks, and devices. Use it to pick the brands, merchants,
and categories of a `SKUs` block, then size the block with
[Estimate Audience Size](/api/v2/audiences#post-apiv2analysesaudiencesestimate).
The period ends on the settled day of
[Get SKUs Coverage](#get-apiv2analysesreferenceskuscoverage), and the figures
are updated once a day. The list is empty until the first daily update has
run, and for an account without the `SKUs` dataset.

**Auth:** bearer token + `Accept: application/json`. Rate limit: read bucket
(120 requests/min).

### Query parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `dimension` | string | Yes | What to rank: `brand` (product brands), `merchant` (merchants), `category` (the categories one level under `category`, or the top level without it), or `total` (one item, the totals of the period, category, and merchant). |
| `period` | integer | No | The days counted: `7`, `30`, or `90` (default `30`). |
| `category` | integer | No | A category id from [Get SKUs Categories](#get-apiv2analysesreferenceskuscategories): count only the orders under it. |
| `merchant` | string | No | A merchant key from [Get SKUs Merchants](#get-apiv2analysesreferenceskusmerchants): count only that merchant's orders. Not with `dimension=merchant`, which is refused with a `422`. |
| `limit` | integer | No | The most items to return, `1` to `50` (default `20`). |

A category or a merchant with no data answers an empty list, and so does a
retired or sensitive category. The read is not searched or paged: `search`,
`page`, and `per_page` are refused, so read the names with the catalogs above.
Any other parameter, such as `categories` or `merchants`, is refused with a
`422` that names it: use `category` and `merchant`.

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/skus/insights?dimension=brand&category=3530&limit=10" \
    -H "Authorization: Bearer <YOUR_TOKEN>" \
    -H "Accept: application/json"
  ```
  {{< /tab >}}

  {{< tab name="Python" >}}
  ```python
  import requests

  res = requests.get(
      "https://console.intuizi.com/api/v2/analyses/reference/skus/insights",
      params={"dimension": "brand", "category": 3530, "limit": 10},
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
  )
  top_brands = [row["value"] for row in res.json()["data"]]
  ```
  {{< /tab >}}

  {{< tab name="JavaScript" >}}
  ```javascript
  const res = await fetch(
    "https://console.intuizi.com/api/v2/analyses/reference/skus/insights?dimension=brand&category=3530&limit=10",
    { headers: { Authorization: "Bearer <YOUR_TOKEN>", Accept: "application/json" } }
  );
  const topBrands = (await res.json()).data.map((row) => row.value);
  ```
  {{< /tab >}}

  {{< tab name="PHP" >}}
  ```php
  $res = Http::withToken('<YOUR_TOKEN>')->acceptJson()
      ->get('https://console.intuizi.com/api/v2/analyses/reference/skus/insights', [
          'dimension' => 'brand',
          'category' => 3530,
          'limit' => 10,
      ]);
  $topBrands = collect($res->json('data'))->pluck('value');
  ```
  {{< /tab >}}

{{< /tabs >}}

### Response

The items with the most orders come first. Items with the same orders are in
the order of their `value`: by number for category ids, and in byte order for
brand and merchant keys.

| Field | Type | Description |
| --- | --- | --- |
| `value` | string or integer | The brand key (what `brands` takes), the merchant key (what `merchants` takes), the category id as an integer (what `categories` takes), or `ALL` on the total item. Only the brands of [Get SKUs Brands](#get-apiv2analysesreferenceskusbrands) and the merchants of [Get SKUs Merchants](#get-apiv2analysesreferenceskusmerchants) are listed, so every `value` can go into a `SKUs` block. |
| `text` | string | The brand, merchant, or category name. The total item shows `All`. |
| `path` | string or null | Category items only: the full path of the category, or `null` when the category is no longer in the tree. |
| `orders` | integer | The orders in the period. |
| `spend` | number | The USD of the purchase lines counted, as delivered by the panel. |
| `avg_order_value` | number | `spend` divided by `orders`, 2 decimals. Every listed item has at least 10 orders. |
| `networks` | integer | The home networks the purchase clicks came from. |
| `devices` | integer or null | The devices seen on those home networks, or `null` when there are fewer than 10. |
| `share_of_orders` | number or null | `orders` divided by the orders of the total item of the same period, category, and merchant (for `dimension=merchant`, of every merchant), 4 decimals. `null` when that total is not listed. |
| `as_of` | string | The last day counted, `YYYY-MM-DD`. |
| `period_days` | integer | The period, in days. |

- **Panel counts.** The figures are panel counts, not a merchant's sales (see
  [What the data is](#what-the-data-is)). `networks` and `devices` are
  approximate, so never add them across items: one home network can buy
  several brands.
- **Small cells.** Rows with fewer than 10 home networks are not listed, nor
  rows with fewer than 10 orders. Of the brands and the categories, at most the
  top 50 of each period, category, and merchant are kept.
- **Categories.** A retired or sensitive category is never listed, as in
  [Get SKUs Categories](#get-apiv2analysesreferenceskuscategories).
- **Shares.** An order with two brands counts under both, so the shares of
  brands can add up to more than 100%.

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "value": "purina", "text": "Purina", "orders": 4210, "spend": 170512.37, "avg_order_value": 40.5, "networks": 3120, "devices": 9350, "share_of_orders": 0.2412, "as_of": "2026-11-10", "period_days": 30 },
    { "value": "dove", "text": "Dove", "orders": 2980, "spend": 71233.1, "avg_order_value": 23.9, "networks": 2240, "devices": 6710, "share_of_orders": 0.1707, "as_of": "2026-11-10", "period_days": 30 }
  ]
}
```

A `category` item also has `path`:

```json
{ "value": 543682, "text": "Non-prescription Dog Food", "path": "Animals & Pet Supplies > Pet Supplies > Dog Supplies > Dog Food > Non-prescription Dog Food", "orders": 15210, "spend": 598311.42, "avg_order_value": 39.34, "networks": 10870, "devices": 32480, "share_of_orders": 0.8715, "as_of": "2026-11-10", "period_days": 30 }
```
