# Common


Reference catalogs shared across the datasets - geography (countries, states,
cities, DMAs), languages, signal providers, dataset types, operators and the
schedule cadence/window/ending catalogs - plus your company's activation
destinations. Every read here is authenticated and
JSON-only (bearer token + `Accept: application/json`) and uses the read rate
bucket (120 requests/min per caller).

## Get Countries {#get-apiv2analysesreferencecommoncountries}

`GET /api/v2/analyses/reference/common/countries`

Countries available to you, optionally filtered by dataset type. Flat list.

### Query parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `datasetType` | string | No | Filter the list to a dataset type (e.g. `WebDomain`), as returned by [Get Dataset Types](#get-apiv2analysesreferencecommondataset-types). |
| `search` | string | No | Optional free-text filter on the item label (case-insensitive contains). |

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/countries?datasetType=WebDomain" \
    -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/common/countries",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
      params={"datasetType": "WebDomain"},
  )
  countries = res.json()["data"]
  ```
  {{< /tab >}}

  {{< tab name="JavaScript" >}}
  ```javascript
  const res = await fetch(
    "https://console.intuizi.com/api/v2/analyses/reference/common/countries?datasetType=WebDomain",
    { headers: { Authorization: "Bearer <YOUR_TOKEN>", Accept: "application/json" } }
  );
  const countries = (await res.json()).data;
  ```
  {{< /tab >}}

  {{< tab name="PHP" >}}
  ```php
  $res = Http::withToken('<YOUR_TOKEN>')->acceptJson()
      ->get('https://console.intuizi.com/api/v2/analyses/reference/common/countries', ['datasetType' => 'WebDomain']);
  $countries = $res->json('data');
  ```
  {{< /tab >}}

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "value": "USA", "text": "United States (USA)" }
  ]
}
```

## Get States {#get-apiv2analysesreferencecommonstates}

`GET /api/v2/analyses/reference/common/states`

States for the given country codes (cascades from the selected countries). Flat
list. The full state catalog is never published - `countries` is required and
a request without it returns a `422` validation error.

### Query parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `countries` | string[] | Yes | Country codes to resolve states for (e.g. `["USA"]`). |
| `search` | string | No | Optional free-text filter on the item label (case-insensitive contains). |

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/states?countries[]=USA" \
    -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/common/states",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
      params={"countries[]": "USA"},
  )
  states = res.json()["data"]
  ```
  {{< /tab >}}

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

  {{< tab name="PHP" >}}
  ```php
  $res = Http::withToken('<YOUR_TOKEN>')->acceptJson()
      ->get('https://console.intuizi.com/api/v2/analyses/reference/common/states', ['countries' => ['USA']]);
  $states = $res->json('data');
  ```
  {{< /tab >}}

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "value": "NY", "text": "New York (NY)" }
  ]
}
```

## Get Cities {#get-apiv2analysesreferencecommoncities}

`GET /api/v2/analyses/reference/common/cities`

Cities for the given state codes (cascades from the selected states). Flat list.
The full city catalog is never published - `states` is required and a request
without it returns a `422` validation error. An optional `dmas` parameter
narrows the cities to the selected DMAs (geo hierarchy: countries -> states ->
DMAs -> cities -> zipcodes); with `dmas` set the cities come from the POI
locations within those markets.

### Query parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `states` | string[] | Yes | State codes to resolve cities for (e.g. `["NY", "CA"]`). |
| `dmas` | string[] | No | DMA labels to narrow the cities (e.g. `["LOS ANGELES"]`). |
| `search` | string | No | Optional free-text filter on the item label (case-insensitive contains). |

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/cities?states[]=NY" \
    -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/common/cities",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
      params={"states[]": "NY"},
  )
  cities = res.json()["data"]
  ```
  {{< /tab >}}

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

  {{< tab name="PHP" >}}
  ```php
  $res = Http::withToken('<YOUR_TOKEN>')->acceptJson()
      ->get('https://console.intuizi.com/api/v2/analyses/reference/common/cities', ['states' => ['NY']]);
  $cities = $res->json('data');
  ```
  {{< /tab >}}

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "value": "New York", "text": "New York" }
  ]
}
```

## Get DMAs {#get-apiv2analysesreferencecommondmas}

`GET /api/v2/analyses/reference/common/dmas`

Designated market areas within the selected geography, scoped to your
account's POI permissions when a DMA allow-list is set. Values are the DMA
labels carried on the POI locations themselves, so anything you pick here is
guaranteed to match locations when used as a POI dataset filter. Flat list of
`{ value, text }` pairs. The full DMA catalog is never published - `countries`
is required.

### Query parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `countries` | string[] | Yes | Country codes to resolve DMAs for (e.g. `["USA"]`). |
| `states` | string[] | No | State codes to narrow the DMAs (e.g. `["CA"]`). |
| `cities` | string[] | No | City names to narrow the DMAs. |
| `search` | string | No | Optional free-text filter on the item label (case-insensitive contains). |

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/dmas?countries[]=USA" \
    -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/common/dmas",
      params={"countries[]": "USA"},
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
  )
  dmas = res.json()["data"]
  ```
  {{< /tab >}}

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

  {{< tab name="PHP" >}}
  ```php
  $res = Http::withToken('<YOUR_TOKEN>')->acceptJson()
      ->get('https://console.intuizi.com/api/v2/analyses/reference/common/dmas', ['countries' => ['USA']]);
  $dmas = $res->json('data');
  ```
  {{< /tab >}}

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "value": "501 - New York, NY", "text": "501 - New York, NY" }
  ]
}
```

## Get Zipcodes {#get-apiv2analysesreferencecommonzipcodes}

`GET /api/v2/analyses/reference/common/zipcodes`

Zip codes carried on the POI locations within the selected cities - the level
directly above a zip in the geo hierarchy (countries -> states -> DMAs ->
cities -> zipcodes) - so anything you pick here is guaranteed to match
locations when used as a POI dataset filter. Paginated. The full zipcode
catalog is never published - `cities` is required and a request without it
returns a `422` validation error. Optional `states`/`dmas`/`countries` narrow
further (useful because city names collide across states and markets).

### Query parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `cities` | string[] | Yes | City names to resolve zipcodes for (e.g. `["Los Angeles"]`). |
| `states` | string[] | No | State codes to narrow the zipcodes (e.g. `["CA"]`). |
| `dmas` | string[] | No | DMA labels to narrow the zipcodes. |
| `countries` | string[] | No | Country codes to narrow the zipcodes (e.g. `["USA"]`). |
| `page` | integer | No | Page to fetch. Defaults to 1. |
| `per_page` | integer | No | Items per page. Defaults to 500, capped at 500. |
| `search` | string | No | Free-text search on the zip code. |

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/zipcodes?cities[]=Los Angeles&states[]=CA" \
    -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/common/zipcodes",
      params={"cities[]": "Los Angeles", "states[]": "CA"},
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
  )
  zipcodes = res.json()["data"]
  ```
  {{< /tab >}}

  {{< tab name="JavaScript" >}}
  ```javascript
  const res = await fetch(
    "https://console.intuizi.com/api/v2/analyses/reference/common/zipcodes?cities[]=Los Angeles&states[]=CA",
    { headers: { Authorization: "Bearer <YOUR_TOKEN>", Accept: "application/json" } }
  );
  const zipcodes = (await res.json()).data;
  ```
  {{< /tab >}}

  {{< tab name="PHP" >}}
  ```php
  $res = Http::withToken('<YOUR_TOKEN>')->acceptJson()
      ->get('https://console.intuizi.com/api/v2/analyses/reference/common/zipcodes', [
          'cities' => ['Los Angeles'],
          'states' => ['CA'],
      ]);
  $zipcodes = $res->json('data');
  ```
  {{< /tab >}}

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": {
    "items": [
      { "value": "90001", "text": "90001" }
    ],
    "pagination": { "current_page": 1, "per_page": 500, "total": 7374, "last_page": 15 }
  }
}
```

## Get Languages {#get-apiv2analysesreferencecommonlanguages}

`GET /api/v2/analyses/reference/common/languages`

Languages, paginated and searchable.

### Query parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `page` | integer | No | Page to fetch. Defaults to 1. |
| `per_page` | integer | No | Items per page. Defaults to 500, capped at 500. |
| `search` | string | No | Free-text search on code or name. |

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/languages?search=english&per_page=500" \
    -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/common/languages",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
      params={"search": "english", "per_page": 500},
  )
  page = res.json()["data"]
  ```
  {{< /tab >}}

  {{< tab name="JavaScript" >}}
  ```javascript
  const res = await fetch(
    "https://console.intuizi.com/api/v2/analyses/reference/common/languages?search=english&per_page=500",
    { headers: { Authorization: "Bearer <YOUR_TOKEN>", Accept: "application/json" } }
  );
  const page = (await res.json()).data;
  ```
  {{< /tab >}}

  {{< tab name="PHP" >}}
  ```php
  $res = Http::withToken('<YOUR_TOKEN>')->acceptJson()
      ->get('https://console.intuizi.com/api/v2/analyses/reference/common/languages', ['search' => 'english', 'per_page' => 500]);
  $page = $res->json('data');
  ```
  {{< /tab >}}

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": {
    "items": [
      { "value": "en", "text": "English (en)" }
    ],
    "pagination": { "current_page": 1, "per_page": 500, "total": 1, "last_page": 1 }
  }
}
```

## Get Signal Providers {#get-apiv2analysesreferencecommonsignal-providers}

`GET /api/v2/analyses/reference/common/signal-providers`

Signal providers (BIDs) permitted for you for a given dataset type. Flat list of
`{ value, text }` pairs.

### Query parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `dataType` | string | Yes | The dataset type to resolve providers for (e.g. `WebDomain`), as returned by [Get Dataset Types](#get-apiv2analysesreferencecommondataset-types). |
| `search` | string | No | Optional free-text filter on the item label (case-insensitive contains). |

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/signal-providers?dataType=WebDomain" \
    -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/common/signal-providers",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
      params={"dataType": "WebDomain"},
  )
  providers = res.json()["data"]
  ```
  {{< /tab >}}

  {{< tab name="JavaScript" >}}
  ```javascript
  const res = await fetch(
    "https://console.intuizi.com/api/v2/analyses/reference/common/signal-providers?dataType=WebDomain",
    { headers: { Authorization: "Bearer <YOUR_TOKEN>", Accept: "application/json" } }
  );
  const providers = (await res.json()).data;
  ```
  {{< /tab >}}

  {{< tab name="PHP" >}}
  ```php
  $res = Http::withToken('<YOUR_TOKEN>')->acceptJson()
      ->get('https://console.intuizi.com/api/v2/analyses/reference/common/signal-providers', ['dataType' => 'WebDomain']);
  $providers = $res->json('data');
  ```
  {{< /tab >}}

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "value": "BID-123", "text": "BID-123" }
  ]
}
```

## Get Endpoint Partners {#get-apiv2analysesreferencecommonendpoint-partners}

`GET /api/v2/analyses/reference/common/endpoint-partners`

Activation partners enabled for your company. Flat list of `{ id, name }`.
Partner inputs, info and credentials are never exposed.

### Query parameters

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

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/endpoint-partners" \
    -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/common/endpoint-partners",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
  )
  partners = res.json()["data"]
  ```
  {{< /tab >}}

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

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

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "id": 3, "name": "Acme DSP" }
  ]
}
```

## Get Endpoint Connections {#get-apiv2analysesreferencecommonendpoint-connections}

`GET /api/v2/analyses/reference/common/endpoint-connections`

Endpoint connections owned by your company. Flat list of `{ id, name, partner }`
where `partner` carries `{ id, name, inputs }` (or `null`). `partner.inputs` are
the partner's activation input **definitions** - `name`, `type` (`text` or
`file`), `required`, and UI hints - in the exact order the
[activation create]({{< relref "/api/v2/activations" >}}) `audience_inputs` and
`datastreams[].inputs` arrays are matched by index. A `file`-type input is the
service-account JSON key (GCP-style partners), supplied on activate as
`datastreams[].service_account`. Only the definitions are returned - stored
input values and connection credentials are never exposed.

### Query parameters

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

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/endpoint-connections" \
    -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/common/endpoint-connections",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
  )
  connections = res.json()["data"]
  ```
  {{< /tab >}}

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

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

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    {
      "id": 12,
      "name": "Acme Production",
      "partner": {
        "id": 3,
        "name": "Acme DSP",
        "inputs": [
          { "name": "Account ID", "type": "text", "required": true, "description": "Partner account id", "placeholder": "Account ID", "default_value": null },
          { "name": "Account Credentials", "type": "file", "required": true, "description": "Service Account .json file", "placeholder": "Service Account .json file", "default_value": null }
        ]
      }
    }
  ]
}
```

## Get Pricing Models {#get-apiv2analysesreferencecommonpricing-models}

`GET /api/v2/analyses/reference/common/pricing-models`

Public pricing models attached to an endpoint partner. Flat list of `{ id, name,
price }`.

### Query parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `partner_id` | integer | Yes | The endpoint partner id to list pricing models for. |
| `search` | string | No | Optional free-text filter on the item label (case-insensitive contains). |

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/pricing-models?partner_id=3" \
    -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/common/pricing-models",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
      params={"partner_id": 3},
  )
  models = res.json()["data"]
  ```
  {{< /tab >}}

  {{< tab name="JavaScript" >}}
  ```javascript
  const res = await fetch(
    "https://console.intuizi.com/api/v2/analyses/reference/common/pricing-models?partner_id=3",
    { headers: { Authorization: "Bearer <YOUR_TOKEN>", Accept: "application/json" } }
  );
  const models = (await res.json()).data;
  ```
  {{< /tab >}}

  {{< tab name="PHP" >}}
  ```php
  $res = Http::withToken('<YOUR_TOKEN>')->acceptJson()
      ->get('https://console.intuizi.com/api/v2/analyses/reference/common/pricing-models', ['partner_id' => 3]);
  $models = $res->json('data');
  ```
  {{< /tab >}}

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "id": 9, "name": "CPM", "price": "2.50" }
  ]
}
```

## Get Datastreams {#get-apiv2analysesreferencecommondatastreams}

`GET /api/v2/analyses/reference/common/datastreams`

Datastreams attached to an endpoint partner. Flat list of `{ id, name, dataset_types }`.

`dataset_types` are the lowercased dataset types the stream applies to (a
lookalike audience counts as `cohorts`). [Create Activation]({{< relref "/api/v2/activations" >}})
rejects an enabled stream that applies to none of the audience's dataset types
with a `422`, so filter on this before you activate.

### Query parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `partner_id` | integer | Yes | The endpoint partner id to list datastreams for. |
| `search` | string | No | Optional free-text filter on the item label (case-insensitive contains). |

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/datastreams?partner_id=3" \
    -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/common/datastreams",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
      params={"partner_id": 3},
  )
  datastreams = res.json()["data"]
  ```
  {{< /tab >}}

  {{< tab name="JavaScript" >}}
  ```javascript
  const res = await fetch(
    "https://console.intuizi.com/api/v2/analyses/reference/common/datastreams?partner_id=3",
    { headers: { Authorization: "Bearer <YOUR_TOKEN>", Accept: "application/json" } }
  );
  const datastreams = (await res.json()).data;
  ```
  {{< /tab >}}

  {{< tab name="PHP" >}}
  ```php
  $res = Http::withToken('<YOUR_TOKEN>')->acceptJson()
      ->get('https://console.intuizi.com/api/v2/analyses/reference/common/datastreams', ['partner_id' => 3]);
  $datastreams = $res->json('data');
  ```
  {{< /tab >}}

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "id": 7, "name": "Match File", "dataset_types": ["poi", "competitors"] }
  ]
}
```

## Get Datastream Visualizations {#get-apiv2analysesreferencecommondatastream-visualizations}

`GET /api/v2/analyses/reference/common/datastream-visualizations`

The data streams an audience can generate charts from, for use in
[`datastreams[]`]({{< relref "/api/v2/audiences" >}}#datastream-visualizations)
on create.

**Not the same catalog as [Get Datastreams](#get-apiv2analysesreferencecommondatastreams).**
Those are an endpoint partner's delivery outputs, chosen per partner. These are
visualizations, chosen per dataset, and the list is scoped to what you are
permitted to see: every public stream plus the private ones assigned to your
company. Streams with no active visualization are never listed.

The charts themselves are viewed in the Intuizi console, on the audience's Data
Streams tab. This API does not return visualization payloads or a PDF export.

### Query parameters

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `dataset_type` | string | No | Return only the streams that apply to this dataset type, e.g. `POI`. This is the set `create` accepts for a dataset of that type. |
| `search` | string | No | Optional free-text filter on the item label (case-insensitive contains). |

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/datastream-visualizations?dataset_type=POI" \
    -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/common/datastream-visualizations",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
      params={"dataset_type": "POI"},
  )
  streams = res.json()["data"]
  ```
  {{< /tab >}}

  {{< tab name="JavaScript" >}}
  ```javascript
  const res = await fetch(
    "https://console.intuizi.com/api/v2/analyses/reference/common/datastream-visualizations?dataset_type=POI",
    { headers: { Authorization: "Bearer <YOUR_TOKEN>", Accept: "application/json" } }
  );
  const streams = (await res.json()).data;
  ```
  {{< /tab >}}

  {{< tab name="PHP" >}}
  ```php
  $res = Http::withToken('<YOUR_TOKEN>')->acceptJson()
      ->get('https://console.intuizi.com/api/v2/analyses/reference/common/datastream-visualizations', ['dataset_type' => 'POI']);
  $streams = $res->json('data');
  ```
  {{< /tab >}}

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    {
      "id": 14,
      "slug": "dwell_time",
      "name": "Dwell Time",
      "dataset_types": ["poi", "competitors"],
      "visual_count": 13
    }
  ]
}
```

## Get Dataset Types {#get-apiv2analysesreferencecommondataset-types}

`GET /api/v2/analyses/reference/common/dataset-types`

The dataset types your company is entitled to, intersected with the types the
audience create endpoint supports. Use the
returned `value` as a dataset's `type` when you
[create an audience]({{< relref "/api/v2/audiences" >}}#post-apiv2analysesaudiencescreate).
Flat list of `{ value, text }` pairs, company-scoped.

### Query parameters

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

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/dataset-types" \
    -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/common/dataset-types",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
  )
  dataset_types = res.json()["data"]
  ```
  {{< /tab >}}

  {{< tab name="JavaScript" >}}
  ```javascript
  const res = await fetch(
    "https://console.intuizi.com/api/v2/analyses/reference/common/dataset-types",
    { headers: { Authorization: "Bearer <YOUR_TOKEN>", Accept: "application/json" } }
  );
  const datasetTypes = (await res.json()).data;
  ```
  {{< /tab >}}

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

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "value": "WebDomain", "text": "Web Domain" },
    { "value": "Apps", "text": "Apps" }
  ]
}
```

## Get Operators {#get-apiv2analysesreferencecommonoperators}

`GET /api/v2/analyses/reference/common/operators`

The operators for combining two datasets in an
[audience create]({{< relref "/api/v2/audiences" >}}#post-apiv2analysesaudiencescreate):
`AND`, `OR`, and `NOTIN`. Use the returned `value` as the audience `operator` when
you send two datasets. Flat list of `{ value, text }` pairs. (The single-dataset
sentinel `Single` is internal and is never returned here.)

### Query parameters

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

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/operators" \
    -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/common/operators",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
  )
  operators = res.json()["data"]
  ```
  {{< /tab >}}

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

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

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "value": "AND", "text": "AND" },
    { "value": "OR", "text": "OR" },
    { "value": "NOTIN", "text": "NOTIN" }
  ]
}
```


## Get Schedule Frequencies {#get-apiv2analysesreferencecommonschedule-frequencies}

`GET /api/v2/analyses/reference/common/schedule-frequencies`

The cadence values a [schedule]({{< relref "/api/v2/schedules" >}}) may run on.
Use the returned `value` as `recurrence.frequency` in
[Create Schedule]({{< relref "/api/v2/schedules" >}}#post-apiv2analysesschedulescreate).
Flat list of `{ value, text }` pairs.

### Query parameters

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

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/schedule-frequencies" \
    -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/common/schedule-frequencies",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
  )
  frequencies = res.json()["data"]
  ```
  {{< /tab >}}

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

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

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "value": "daily", "text": "Daily" },
    { "value": "weekly", "text": "Weekly" },
    { "value": "bi-weekly", "text": "Bi-Weekly" },
    { "value": "monthly", "text": "Monthly" }
  ]
}
```

## Get Schedule Windows {#get-apiv2analysesreferencecommonschedule-windows}

`GET /api/v2/analyses/reference/common/schedule-windows`

The rolling data windows a [schedule]({{< relref "/api/v2/schedules" >}}) may
rebuild its audience over. Use the returned `id` as `recurrence.window_type` in
[Create Schedule]({{< relref "/api/v2/schedules" >}}#post-apiv2analysesschedulescreate);
the `Custom` window additionally requires `recurrence.window_days`. Flat list of
`{ id, name }` pairs.

### Query parameters

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

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/schedule-windows" \
    -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/common/schedule-windows",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
  )
  windows = res.json()["data"]
  ```
  {{< /tab >}}

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

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

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "id": 1, "name": "Last 7 Days" },
    { "id": 2, "name": "Last Full Month" },
    { "id": 3, "name": "Custom" },
    { "id": 4, "name": "Last 30 Days" },
    { "id": 5, "name": "Last 90 Days" },
    { "id": 6, "name": "Month To Date" },
    { "id": 7, "name": "Last 3 Full Months" },
    { "id": 8, "name": "Year To Date" }
  ]
}
```

## Get Schedule Endings {#get-apiv2analysesreferencecommonschedule-endings}

`GET /api/v2/analyses/reference/common/schedule-endings`

The ways a [schedule]({{< relref "/api/v2/schedules" >}}) can end. Use the
returned `id` as `recurrence.ending.type` in
[Create Schedule]({{< relref "/api/v2/schedules" >}}#post-apiv2analysesschedulescreate):
`Recurrences` additionally requires `recurrence.ending.after_recurrences`, and
`Custom Date` requires `recurrence.ending.end_date`, on or after the date of
`recurrence.start`. Flat list of `{ id, name }` pairs.

### Query parameters

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

{{< tabs >}}

  {{< tab name="cURL" >}}
  ```bash
  curl "https://console.intuizi.com/api/v2/analyses/reference/common/schedule-endings" \
    -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/common/schedule-endings",
      headers={"Authorization": "Bearer <YOUR_TOKEN>", "Accept": "application/json"},
  )
  endings = res.json()["data"]
  ```
  {{< /tab >}}

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

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

{{< /tabs >}}

### Response

```json
{
  "status": "success",
  "code": 200,
  "message": "Resources fetched successfully.",
  "data": [
    { "id": 1, "name": "Never" },
    { "id": 2, "name": "Recurrences" },
    { "id": 3, "name": "Custom Date" }
  ]
}
```