> ## Documentation Index
> Fetch the complete documentation index at: https://docs.permutive.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Viant

> Activate your Permutive audiences in Viant (Adelphic) for programmatic campaign targeting

export const YesBadge = () => {
  return <span style={{
    display: 'inline-block',
    padding: '0.125rem 0.5rem',
    borderRadius: '0.25rem',
    fontSize: '0.625rem',
    background: '#C7E8F9',
    color: '#1A1A1A',
    fontWeight: '500'
  }}>
      Yes
    </span>;
};

export const BadgeRowCenter = ({label, children}) => {
  return <div style={{
    display: 'flex',
    justifyContent: 'space-between',
    alignItems: 'center',
    marginBottom: '0.5rem'
  }}>
      <span style={{
    fontSize: '0.625rem',
    color: '#6b7280',
    textTransform: 'uppercase',
    fontWeight: '500',
    letterSpacing: '0.05em'
  }}>
        {label}
      </span>
      {children}
    </div>;
};

export const BadgeRow = ({label, children}) => {
  return <div style={{
    display: 'flex',
    justifyContent: 'space-between',
    alignItems: 'flex-start',
    marginBottom: '0.5rem'
  }}>
      <span style={{
    fontSize: '0.625rem',
    color: '#6b7280',
    textTransform: 'uppercase',
    fontWeight: '500',
    letterSpacing: '0.05em'
  }}>
        {label}
      </span>
      {children}
    </div>;
};

export const BadgeContainer = ({children}) => {
  return <div style={{
    display: 'flex',
    gap: '0.25rem',
    flexWrap: 'wrap',
    justifyContent: 'flex-end',
    minWidth: '0',
    flex: '1'
  }}>
      {children}
    </div>;
};

export const ProductRequiredBadge = ({product}) => {
  const getBadgeStyle = product => {
    switch (product) {
      case 'Core Platform':
        return {
          background: '#CB88FC',
          color: '#1A1A1A'
        };
        --purple;
      case 'Routing':
        return {
          background: '#CB88FC',
          color: '#1A1A1A'
        };
        --purple;
      case 'Contextual':
        return {
          background: '#CB88FC',
          color: '#1A1A1A'
        };
        --purple;
      default:
        return {
          background: '#A7B3D9',
          color: '#1A1A1A'
        };
        --haze;
    }
  };
  const style = getBadgeStyle(product);
  return <span style={{
    display: 'inline-block',
    padding: '0.125rem 0.375rem',
    borderRadius: '0.25rem',
    fontSize: '0.625rem',
    background: style.background,
    color: style.color,
    fontWeight: '500'
  }}>
      {product}
    </span>;
};

export const SdkRequiredBadge = ({required}) => {
  const getBadgeStyle = required => {
    switch (required) {
      case 'Yes':
        return {
          background: '#C7E8F9',
          color: '#1A1A1A'
        };
        --blue;
      case 'No':
        return {
          background: '#F7D0E2',
          color: '#1A1A1A'
        };
        --pink;
      default:
        return {
          background: '#A7B3D9',
          color: '#1A1A1A'
        };
        --haze;
    }
  };
  const style = getBadgeStyle(required);
  return <span style={{
    display: 'inline-block',
    padding: '0.125rem 0.375rem',
    borderRadius: '0.25rem',
    fontSize: '0.625rem',
    background: style.background,
    color: style.color,
    fontWeight: '500'
  }}>
      {required}
    </span>;
};

export const CapabilityBadge = ({capability}) => {
  const getBadgeStyle = capability => {
    switch (capability) {
      case 'Event Collection':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      case 'Cohort Activation':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      case 'Campaign Optimization':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      case 'Identity Signal':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      case 'Contextual Signal':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      case 'Connectivity':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      case 'Routing':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      case 'Data Collaboration':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      default:
        return {
          background: '#A7B3D9',
          color: '#1A1A1A'
        };
        --haze;
    }
  };
  const style = getBadgeStyle(capability);
  return <span style={{
    display: 'inline-block',
    padding: '0.125rem 0.375rem',
    borderRadius: '0.25rem',
    fontSize: '0.625rem',
    background: style.background,
    color: style.color,
    fontWeight: '500',
    whiteSpace: 'nowrap'
  }}>
      {capability}
    </span>;
};

export const EnvironmentBadge = ({environment}) => {
  const getBadgeStyle = environment => {
    switch (environment) {
      case 'Web':
        return {
          background: '#F9C1A8',
          color: '#1A1A1A'
        };
        --peach;
      case 'iOS':
        return {
          background: '#F9C1A8',
          color: '#1A1A1A'
        };
        --peach;
      case 'Android':
        return {
          background: '#F9C1A8',
          color: '#1A1A1A'
        };
        --peach;
      case 'CTV':
        return {
          background: '#F9C1A8',
          color: '#1A1A1A'
        };
        --peach;
      case 'API Direct':
        return {
          background: '#F9C1A8',
          color: '#1A1A1A'
        };
        --peach;
      default:
        return {
          background: '#A7B3D9',
          color: '#1A1A1A'
        };
        --haze;
    }
  };
  const style = getBadgeStyle(environment);
  return <span style={{
    display: 'inline-block',
    padding: '0.125rem 0.375rem',
    borderRadius: '0.25rem',
    fontSize: '0.625rem',
    background: style.background,
    color: style.color,
    fontWeight: '500',
    whiteSpace: 'nowrap'
  }}>
      {environment}
    </span>;
};

export const DirectionBadge = ({direction}) => {
  const getBadgeStyle = direction => {
    switch (direction) {
      case 'Bidirectional':
        return {
          background: '#FA8784',
          color: '#1A1A1A'
        };
        --tomato;
      case 'Destination':
        return {
          background: '#FA8784',
          color: '#1A1A1A'
        };
        --tomato;
      case 'Source':
        return {
          background: '#FA8784',
          color: '#1A1A1A'
        };
        --tomato;
      default:
        return {
          background: '#A7B3D9',
          color: '#1A1A1A'
        };
        --haze;
    }
  };
  const style = getBadgeStyle(direction);
  return <span style={{
    display: 'inline-block',
    padding: '0.125rem 0.375rem',
    borderRadius: '0.25rem',
    fontSize: '0.625rem',
    background: style.background,
    color: style.color,
    fontWeight: '500'
  }}>
      {direction}
    </span>;
};

<Card title="">
  <div style={{ display: 'flex', alignItems: 'center', marginBottom: '1rem' }}>
    <div style={{ width: '32px', height: '32px', marginRight: '0.75rem', display: 'flex', alignItems: 'center', justifyContent: 'center', flexShrink: 0 }}>
      <img src="https://mintcdn.com/permutive/--H2YuQUMQRJBn3e/images/integrations/logos/viant.png?fit=max&auto=format&n=--H2YuQUMQRJBn3e&q=85&s=547a50cc7a777bdedb27decc9c8e0e21" alt="Viant" style={{ maxWidth: '32px', maxHeight: '32px', display: 'block' }} width="512" height="512" data-path="images/integrations/logos/viant.png" />
    </div>

    <h3 style={{ margin: 0, fontSize: '1.125rem', fontWeight: '600' }}>Viant</h3>
  </div>

  <div style={{ marginBottom: '1rem' }}>
    <BadgeRowCenter label="Direction">
      <DirectionBadge direction="Destination" />
    </BadgeRowCenter>

    <BadgeRowCenter label="Environment">
      <BadgeContainer>
        <EnvironmentBadge environment="Web" />

        <EnvironmentBadge environment="iOS" />

        <EnvironmentBadge environment="Android" />

        <EnvironmentBadge environment="CTV" />

        <EnvironmentBadge environment="API Direct" />
      </BadgeContainer>
    </BadgeRowCenter>

    <BadgeRowCenter label="Capability">
      <BadgeContainer>
        <CapabilityBadge capability="Cohort Activation" />
      </BadgeContainer>
    </BadgeRowCenter>

    <BadgeRowCenter label="SDK Required">
      <SdkRequiredBadge required="Yes" />
    </BadgeRowCenter>

    <BadgeRowCenter label="Product(s) Required">
      <ProductRequiredBadge product="Core Platform" />
    </BadgeRowCenter>
  </div>

  <p style={{ margin: 0, fontSize: '0.875rem', color: '#6b7280', lineHeight: '1.5' }}>
    Viant Technology is an omnichannel demand-side platform (DSP). Its programmatic platform, Adelphic, enables advertisers to plan and execute campaigns across display, video, CTV, audio, and digital out-of-home.
  </p>
</Card>

<CardGroup cols={2}>
  <Card title="Setup" href="#setup" icon="gear" />

  <Card title="Troubleshooting" href="#troubleshooting" icon="wrench" />
</CardGroup>

## Overview

Permutive syncs your audiences to Viant on a daily basis via [server-side identity-based activation](/integrations/server-side-identity-based-activation), so you can target them in programmatic campaigns managed through Viant's Adelphic platform, across display, video, CTV, audio, and digital out-of-home channels.

Data flows one way — from Permutive to Viant. Once synced, your cohorts appear as targetable third-party custom segments in Adelphic, ready for campaign targeting. The integration currently supports non-EU data only — see [Regional availability](#regional-availability).

Use cases include:

* **Audience activation**: Make your Permutive cohorts available for targeting in Viant campaigns managed via Adelphic
* **Cross-device reach**: Reach audiences across web, mobile, and CTV environments
* **Programmatic deals**: Offer enriched audiences to advertisers via private marketplace deals, increasing eCPMs
* **First-party data monetization**: Use first-party behavioral data in programmatic campaigns without relying on third-party cookies

## Environment Compatibility

| Environment    | Supported    | Notes                                                          |
| -------------- | ------------ | -------------------------------------------------------------- |
| **Web**        | <YesBadge /> | Via Viant cookie ([non-EU users only](#regional-availability)) |
| **iOS**        | <YesBadge /> | Via IDFA                                                       |
| **Android**    | <YesBadge /> | Via AAID                                                       |
| **CTV**        | <YesBadge /> | Via IP Address                                                 |
| **API Direct** | <YesBadge /> | Via any supported identifier                                   |

## Supported Identity Tags

Permutive activates your cohorts to Viant by matching users on the identity tags below. A user is included in a sync whenever Permutive holds one of these identifiers for them. Your Permutive CSM configures which tags to sync based on the environments you need to reach.

| Identity Tag (`tag`) | Description                                                                                     | Environment |
| -------------------- | ----------------------------------------------------------------------------------------------- | ----------- |
| `viant`              | Viant cookie ID (collected via the Web SDK ID sync; only synced for users out of scope of GDPR) | Web         |
| `idfa`               | Apple Identifier for Advertisers (IDFA)                                                         | iOS         |
| `aaid`               | Android Advertising ID (AAID)                                                                   | Android     |
| `ip_address`         | IP Address                                                                                      | CTV         |

<Note>
  Identity-based activation requires that Permutive is collecting the identity tags you want to use. Work with your Permutive CSM to confirm identity collection is configured for your selected tags.
</Note>

## Regional Availability

This integration is currently restricted to non-EU data only:

* The Viant cookie is only synced when a user is out of scope of GDPR — indicated by the TCF API not being present on the page, or the TCF status indicating GDPR does not apply.
* Data is only transferred to Viant for users determined to be located outside of Europe.

If your audiences include a significant proportion of EU users, expect the activated audience size in Viant to be smaller than your total Permutive cohort.

## Prerequisites

* **Viant (Adelphic) account** — An active Viant account with access to the Adelphic platform.
* **Adelphic API credentials** — An Adelphic API username, password, and S3 destination path. Your Viant account team shares these with Permutive directly as part of integration setup.
* **Integration enabled by Permutive** — Your Permutive Customer Success Manager configures and enables the integration on your behalf.

## Setup

Your Permutive CSM handles the integration setup, including configuring your Adelphic API credentials and the identity types to sync. Once the integration is enabled, you can start activating cohorts.

<Steps>
  <Step title="Confirm eligibility with your Permutive CSM">
    Discuss your integration needs with your Permutive Customer Success Manager, who will confirm the integration is a fit for your audiences and environments.
  </Step>

  <Step title="Request setup from Viant">
    Reach out to your Viant account manager to request the integration. Viant shares the Adelphic API credentials and S3 destination path with Permutive directly.
  </Step>

  <Step title="Permutive enables the integration">
    Your Permutive CSM configures and enables the integration for your workspace using the details provided by Viant.
  </Step>

  <Step title="Activate cohorts">
    In the Permutive Dashboard, go to your cohorts and enable the "Viant (ID-based)" activation toggle for each cohort you want to sync to Viant.

    <Info>
      Cohort data syncs to Viant daily. Changes to cohort membership are reflected within 24 hours of the next scheduled sync.
    </Info>
  </Step>

  <Step title="Verify in Adelphic">
    After the first sync completes (within 24 hours), check Adelphic under **Planning → Forecasting → Add Targeting → Data → 3rd party custom segments**. Your segments appear grouped under a parent node named `Permutive | <your display name>`.
  </Step>
</Steps>

<Expandable title="Advanced: Scope a segment to a single advertiser">
  By default, a segment activated to Viant is visible to every advertiser under your seat. If you only want a segment available to a specific advertiser, your Permutive CSM can set an Advertiser ID on that cohort's activation — you can find advertiser IDs in the Adelphic UI. Contact your Permutive CSM to configure this.
</Expandable>

## Data Types

Permutive sends cohort membership data to Viant on a daily basis. Each synced cohort appears in Adelphic as a targetable third-party custom segment, named `<your display name> | <cohort name> (<cohort short ID>)`, grouped under the parent node `Permutive | <your display name>`.

* **Sync frequency:** Daily
* **Updates:** Changes to cohort membership (users entering or exiting) are reflected in the next sync
* **Full refresh:** A complete refresh of all audience data occurs every 28 days by default
* **Pricing:** Segments are delivered at \$0.00 CPM, since they're built from your own first-party data

## Troubleshooting

<AccordionGroup>
  <Accordion title="Audiences not appearing in Adelphic">
    **Possible causes:**

    * The integration was recently enabled and data hasn't synced yet
    * Cohorts are not activated for Viant in the Permutive Dashboard

    **What to do:**

    1. Check that your cohorts have the "Viant (ID-based)" toggle enabled
    2. Wait 24–48 hours after initial activation for the first sync to complete
    3. Confirm that your cohorts have active members in Permutive
    4. Look under **Planning → Forecasting → Add Targeting → Data → 3rd party custom segments** in Adelphic, under the `Permutive | <your display name>` parent node
    5. Contact your Permutive CSM if audiences still don't appear
  </Accordion>

  <Accordion title="Lower-than-expected audience size">
    **Possible causes:**

    * This integration is currently restricted to non-EU data — EU users are excluded from sync, and the Viant cookie only syncs for users determined to be out of scope of GDPR
    * Identity matching rates for your selected identity type(s)
    * Overly restrictive cohort rules

    **What to do:**

    1. If your audience is predominantly EU-based, expect a reduced match — this is expected behavior, not a fault
    2. Ask your Permutive CSM to check that identity collection is working for your selected identity types
    3. Review your cohort rules to ensure they're not too restrictive
    4. Allow 24–48 hours after initial activation for audiences to fully populate
  </Accordion>

  <Accordion title="Segment data not updating in Adelphic">
    **Cause:** Cohort membership changes are not immediate — data syncs daily.

    **What to do:**

    1. Allow up to 24 hours for changes to appear
    2. Verify the cohort still has the "Viant (ID-based)" toggle enabled
    3. Contact your Permutive CSM if data consistently fails to update after 48 hours
  </Accordion>

  <Accordion title="Disabled segments still visible in Adelphic">
    **Cause:** Adelphic has no concept of deleting a segment. When you disable a cohort activation in Permutive, the corresponding segment in Adelphic is archived rather than removed — no new data is sent, but existing user memberships remain until they expire.

    **What to expect:**

    1. After disabling, no new data is sent for that segment
    2. Existing memberships expire automatically once data stops flowing
    3. The segment shows as archived in Adelphic during this period
    4. If you need a segment hidden from targeting sooner, contact Viant directly
  </Accordion>

  <Accordion title="Segment not visible to an expected advertiser">
    **Cause:** The cohort's activation has an Advertiser ID scope configured, restricting the segment to a single advertiser under your seat.

    **What to do:**

    1. Confirm with your Permutive CSM whether an Advertiser ID scope is set on the cohort's Viant activation
    2. If the segment should be visible more broadly, ask your CSM to remove the Advertiser ID scope, or add the correct advertiser
    3. Advertiser IDs can be looked up in the Adelphic UI
  </Accordion>
</AccordionGroup>

## Changelog

### August 2026

* Initial release of Viant DSP integration
* Audience activation support for Web, iOS, Android, and CTV environments

<Info>
  For detailed changelog information, visit our
  [Changelog](https://changelog.permutive.com/).
</Info>