> ## 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.

# LiveRamp RampID

> Integrate with LiveRamp RampID for authenticated identity and programmatic advertising

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

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/pNhz39ducTVcQczh/images/integrations/logos/rampid.svg?fit=max&auto=format&n=pNhz39ducTVcQczh&q=85&s=8996cb26416e675f3119488d40d84ac5" alt="LiveRamp RampID" style={{ maxWidth: '32px', maxHeight: '32px', display: 'block', backgroundColor: '#f3f4f6', borderRadius: '4px', padding: '2px' }} width="1605" height="1087" data-path="images/integrations/logos/rampid.svg" />
    </div>

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

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

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

    <BadgeRowCenter label="Capability">
      <BadgeContainer>
        <CapabilityBadge capability="Identity Signal" />
      </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' }}>
    LiveRamp RampID is a privacy-first, people-based identity solution that enables publishers to maximize programmatic revenue through deterministic and probabilistic user recognition across the open web.
  </p>
</Card>

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

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

## Overview

LiveRamp RampID is an industry-leading identity solution that provides publishers with a people-based identifier to improve addressability in programmatic advertising. The RampID integration with Permutive allows publishers to deploy LiveRamp's Authenticated Traffic Solution (ATS) through the Permutive SDK without additional implementation work.

This integration is a Destination integration:

* **Destination:** Permutive retrieves RampID ephemeral identity envelopes and passes them to the programmatic bidstream via Prebid or Amazon Publisher Services (APS), enabling demand-side platforms (DSPs) to recognize users and improve match rates.

Key features of the RampID integration:

* **Deterministic and Probabilistic Matching:** Uses both hashed emails and probabilistic signals for comprehensive coverage
* **No-Code Integration:** Enable via Permutive dashboard without additional implementation
* **Privacy-First:** Ephemeral envelopes for bidstream use only, with automatic TCF consent handling
* **Industry Standard:** Widely adopted across the advertising ecosystem with strong DSP and SSP support

Use cases include:

* **Yield Optimization:** Enrich programmatic bids with RampID envelopes to increase CPMs and fill rates
* Maximize addressability in a cookie-restricted environment with authenticated and probabilistic signals

<Note>
  RampID identifiers are not ingested into Permutive's identity graph. They are ephemeral signals generated at bid time and passed directly to the bidstream. These IDs cannot be used for Permutive cohort building, identity resolution, or data collaboration features.
</Note>

<Info>
  **Amazon Publisher Services (APS) Support**

  In addition to Prebid, this integration also supports Amazon Publisher Services (APS) for bidstream activation. APS support is currently available on request. If you're interested in using APS, please contact your Customer Success Manager to discuss setup and requirements.
</Info>

## Environment Compatibility

| Environment    | Supported    | Notes                                                |
| -------------- | ------------ | ---------------------------------------------------- |
| **Web**        | <YesBadge /> | Full support via Permutive SDK and Prebid module     |
| **iOS**        | <NoBadge />  | Not supported - RampID focuses on web-based identity |
| **Android**    | <NoBadge />  | Not supported - RampID focuses on web-based identity |
| **CTV**        | <NoBadge />  | Not supported                                        |
| **API Direct** | <NoBadge />  | Not supported                                        |

## Prerequisites

Before enabling the RampID integration, ensure you have the following. These prerequisites are for Prebid integration; for APS integration, contact your Customer Success Manager.

* **LiveRamp Partner Account:** You must have a LiveRamp partnership agreement to use RampID. This typically requires:
  * Signing up for a LiveRamp account at [liveramp.com](https://liveramp.com)
  * Accepting LiveRamp's terms of service
  * Obtaining your unique Partner ID from your LiveRamp account dashboard
  * Note: While publishers can use RampID for free (advertisers pay to decrypt the IDs), you need to register and establish a partnership

* **Consent Management:** RampID must be added to your Consent Management Platform (CMP) as an approved vendor in your TCF vendor list. Without proper consent configuration, RampID will not generate identifiers.
  * Add LiveRamp as a vendor in your TCF implementation
  * Ensure required TCF purposes are configured (consult LiveRamp documentation for specific requirements)
  * LiveRamp typically requires Purpose 1 (Store and/or access information on a device) and may require additional purposes

* **Prebid Integration:** The RampID integration requires the Permutive Identity Manager Prebid module to be enabled. This is a specialized Prebid module separate from the standard Permutive RTD module.
  * The Permutive Identity Manager ID System module must be compiled into your Prebid build
  * See our [Prebid integration guide](/integrations/advertising/bidstream/prebid) for complete setup instructions including the Identity Manager module configuration

* **Permutive SDK:** The Permutive Web SDK must be deployed and operational on your website

* **Hashed Email Collection (Optional but Recommended):** While RampID can work with probabilistic signals alone, maximum effectiveness is achieved when you collect and hash user email addresses:
  * Implement email collection through registration, newsletter signup, or authentication
  * Hash emails using SHA-256 before passing to Permutive
  * Store hashed emails in Permutive's identity graph via the SDK's `identify()` method

## Setup

<Tabs>
  <Tab title="Primary Setup Steps">
    <Steps>
      <Step title="Sign Up for LiveRamp Account">
        Register for a LiveRamp account and establish your partnership:

        1. Visit [liveramp.com](https://liveramp.com) and complete the publisher registration process
        2. Work with your LiveRamp account representative to set up your partnership agreement
        3. Accept LiveRamp's terms of service for the Authenticated Traffic Solution (ATS)
        4. Navigate to your LiveRamp account dashboard and copy your Partner ID (you'll need this in the next step)

        <Note>
          RampID is free for publishers to use. Advertisers pay LiveRamp to decrypt the identity envelopes in the bidstream.
        </Note>
      </Step>

      <Step title="Configure Consent Management">
        Add LiveRamp to your Consent Management Platform:

        1. Log in to your CMP dashboard
        2. Add LiveRamp to your TCF vendor list (LiveRamp's TCF Vendor ID is typically 97)
        3. Ensure the required TCF purposes are enabled for LiveRamp:
           * Purpose 1: Store and/or access information on a device (required)
           * Additional purposes as specified by LiveRamp
        4. Test that consent is properly collected and LiveRamp appears in your consent string

        <Warning>
          If LiveRamp is not properly configured in your CMP, the integration will not generate identifiers, even if enabled in Permutive.
        </Warning>
      </Step>

      <Step title="Enable Prebid Identity Manager Module">
        Ensure the Permutive Identity Manager ID System module is included in your Prebid build:

        1. Check your current Prebid configuration or contact your Prebid implementation team
        2. If the module is not already included, rebuild Prebid with the `permutiveIdentityManagerIdSystem` module
        3. Deploy the updated Prebid build to your website

        <Info>
          The Permutive Identity Manager module is separate from the standard Permutive RTD module. Both can coexist in your Prebid setup. For detailed Prebid configuration instructions including the Identity Manager module setup, see our [Prebid integration guide](/integrations/advertising/bidstream/prebid).
        </Info>
      </Step>

      <Step title="Enable RampID in Permutive Dashboard">
        Activate the RampID integration in Permutive:

        1. Navigate to **Identity** → **Catalog** in your Permutive dashboard
        2. Locate **LiveRamp RampID** in the identity provider catalog
        3. Click **Connect** to begin the configuration process
        4. Enter your LiveRamp Partner ID when prompted
        5. Configure any additional settings as needed
        6. Save the configuration

        The Permutive SDK will automatically begin retrieving RampID identifiers on your next SDK build.
      </Step>

      <Step title="Verify Setup">
        Confirm that RampID identifiers are being generated and passed to Prebid:

        1. Open your website in a browser with developer tools enabled
        2. Navigate to the **Console** tab
        3. Look for Permutive SDK log messages indicating RampID initialization
        4. Check the **Network** tab for API calls to LiveRamp's endpoints (typically `ats.rlcdn.com` or `api.rlcdn.com`)
        5. Inspect Prebid bid requests to verify that `eids` array contains RampID identifiers

        **Expected behavior:**

        * LiveRamp API calls should complete successfully (HTTP 200)
        * Prebid bid requests should include RampID in the `user.eids` array with source `liveramp.com`

        <Expandable title="Example Prebid bid request with RampID">
          ```json theme={"dark"}
          {
            "user": {
              "eids": [
                {
                  "source": "liveramp.com",
                  "uids": [
                    {
                      "id": "AjfowMFS4A96...",
                      "atype": 3,
                      "ext": {
                        "rtiPartner": "idl"
                      }
                    }
                  ]
                }
              ]
            }
          }
          ```
        </Expandable>
      </Step>
    </Steps>

    <Expandable title="Advanced: Configuring Hashed Email Collection">
      To maximize RampID effectiveness, collect and pass hashed email addresses to Permutive:

      1. **Collect Email Addresses:** Implement email collection through:
         * User registration flows
         * Newsletter subscriptions
         * Authentication/login
         * Commerce transactions

      2. **Hash Emails Client-Side:** Before passing to Permutive, hash emails using SHA-256:

      ```javascript theme={"dark"}
      // Example: Hashing email with SubtleCrypto API
      async function hashEmail(email) {
        const normalized = email.toLowerCase().trim();
        const msgBuffer = new TextEncoder().encode(normalized);
        const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer);
        const hashArray = Array.from(new Uint8Array(hashBuffer));
        const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
        return hashHex;
      }

      // Pass hashed email to Permutive
      const hashedEmail = await hashEmail(userEmail);
      permutive.identify([{
        tag: 'email_sha256',
        id: hashedEmail
      }]);
      ```

      3. **Privacy Considerations:**
         * Always obtain proper user consent before collecting and hashing emails
         * Never send unhashed (plaintext) emails to Permutive or any third-party
         * Ensure your privacy policy covers identity provider integrations
         * Respect opt-out requests and delete identifiers as required by privacy regulations

      <Note>
        Hashed emails significantly improve RampID match rates by providing deterministic signals to LiveRamp's identity graph.
      </Note>
    </Expandable>
  </Tab>

  <Tab title="Web">
    ### Web Implementation Details

    The RampID integration operates entirely through the Permutive SDK and requires no additional code implementation from publishers. Once enabled in the dashboard:

    1. **SDK Initialization:** The Permutive SDK automatically detects the RampID configuration during initialization
    2. **Consent Check:** The SDK verifies user consent via the TCF consent string
    3. **Identity Graph Lookup:** The SDK checks if hashed emails or other identifiers are available in the Permutive identity graph
    4. **ID Retrieval:** If consent is granted, the SDK makes a client-side API call to LiveRamp's ATS endpoints to retrieve an ephemeral RampID envelope
    5. **Prebid Activation:** The RampID identifier is passed to the Permutive Identity Manager Prebid module
    6. **Bidstream Injection:** The Prebid module includes the RampID identifier in the `user.eids` array of all bid requests

    ### Technical Flow

    ```mermaid theme={"dark"}
    sequenceDiagram
        participant Page as Publisher Page
        participant SDK as Permutive SDK
        participant CMP as Consent Management
        participant LR as LiveRamp ATS API
        participant Prebid as Prebid.js

        Page->>SDK: SDK Initializes
        SDK->>CMP: Check TCF Consent
        CMP-->>SDK: Consent Granted
        SDK->>SDK: Check Identity Graph
        SDK->>LR: Request RampID Envelope
        LR-->>SDK: Return Encrypted ID
        SDK->>Prebid: Pass ID to Identity Manager
        Prebid->>Prebid: Include in bid requests
    ```
  </Tab>
</Tabs>

## Data Types

The RampID integration does not collect event data into Permutive. Instead, it provides ephemeral identity signals that are passed directly to the programmatic bidstream via Prebid.

### Identity Signals Transmitted

<AccordionGroup>
  <Accordion title="LiveRamp RampID">
    An encrypted identity envelope generated by LiveRamp and passed to demand-side platforms through Prebid's Extended ID (EID) format.

    <ResponseField name="source" type="string">
      Always set to `liveramp.com` to identify the LiveRamp RampID provider in the bidstream
    </ResponseField>

    <ResponseField name="uids[].id" type="string">
      The encrypted RampID identity envelope. This is an ephemeral identifier that varies across requests and cannot be used for long-term tracking. The envelope is encrypted specifically for programmatic use and can only be decrypted by authorized advertisers who pay LiveRamp for access.
    </ResponseField>

    <ResponseField name="uids[].atype" type="integer">
      Authentication type indicator. Typically set to `3` (authenticated) for RampID identifiers derived from hashed emails, or `1` for probabilistic signals
    </ResponseField>

    <ResponseField name="uids[].ext.rtiPartner" type="string">
      LiveRamp's RTI (Real-Time Identity) partner identifier, typically set to `idl` (Identity Link)
    </ResponseField>

    <Note>
      RampID identifiers are not stored in Permutive's identity graph or made available for cohort building. They exist solely for bidstream activation. The encrypted envelopes ensure privacy while enabling advertiser recognition.
    </Note>
  </Accordion>
</AccordionGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="RampID identifiers not appearing in bid requests">
    If RampID identifiers are not showing up in your Prebid bid requests:

    **Check consent configuration:**

    * Verify LiveRamp is listed in your TCF vendor list (typically Vendor ID 97)
    * Ensure required TCF purposes are granted (at minimum Purpose 1)
    * Check the browser console for consent-related errors
    * Test in a fresh browser session or incognito mode to rule out cached consent states
    * Verify the consent string includes LiveRamp using browser developer tools

    **Verify Prebid module:**

    * Confirm the Permutive Identity Manager ID System module is compiled into your Prebid build
    * Check that no Prebid configuration is blocking RampID from the `eids` array
    * Review Prebid console logs for initialization errors
    * Ensure your Prebid version is up to date (module requires Prebid.js 5.0+)

    **Confirm dashboard configuration:**

    * Navigate to Identity → Catalog in Permutive dashboard
    * Verify RampID shows as "Connected" or "Enabled"
    * Ensure your LiveRamp Partner ID is correctly entered
    * Check that an SDK build has occurred since enabling RampID

    **Network connectivity:**

    * Check browser developer tools Network tab for failed API calls to LiveRamp endpoints (`ats.rlcdn.com`, `api.rlcdn.com`)
    * Verify no ad blockers or content security policies are blocking LiveRamp requests
    * Test from different networks to rule out firewall or proxy issues
    * Ensure HTTPS is enabled (LiveRamp requires secure connections)
  </Accordion>

  <Accordion title="LiveRamp account setup and Partner ID location">
    If you're having trouble obtaining your LiveRamp Partner ID:

    1. Ensure you've completed the full partnership agreement with LiveRamp (not just a basic account registration)
    2. Check your email for confirmation or welcome messages from LiveRamp with account details
    3. Log in to your LiveRamp dashboard - the Partner ID is typically displayed in account settings or integration sections
    4. Contact your LiveRamp account representative if you cannot locate your Partner ID
    5. Verify you have access to the Authenticated Traffic Solution (ATS) product specifically

    **Common issue:** Publishers sometimes confuse different LiveRamp products. The RampID integration requires the ATS (Authenticated Traffic Solution) product, not the Data Marketplace or other LiveRamp offerings.

    <Info>
      If you're new to LiveRamp, your account representative can provide detailed onboarding guidance and help you locate all necessary credentials.
    </Info>
  </Accordion>

  <Accordion title="Low RampID match rates or coverage">
    If you're seeing lower than expected RampID coverage:

    **User consent factors:**

    * RampID only generates identifiers for users who grant consent
    * In regions with strict privacy regulations (EU, California), consent rates may be lower
    * Review your consent management strategy and consent request UI
    * Consider A/B testing different consent messaging to improve opt-in rates

    **Email collection factors:**

    * RampID performs best when publishers collect and pass hashed email addresses
    * If you're not collecting emails, consider implementing registration or newsletter signup
    * Ensure emails are properly hashed (SHA-256, lowercase, trimmed of whitespace)
    * Verify hashed emails are being passed to Permutive via the `identify()` method with tag `email_sha256`

    **Technical factors:**

    * Users with strict browser privacy settings may block RampID's signals
    * Safari's Intelligent Tracking Prevention (ITP) may limit effectiveness in some scenarios
    * Incognito/private browsing modes may reduce match rates
    * Ad blockers may interfere with LiveRamp API calls

    **Measurement:**

    * Use the Identity Insights dashboard in Permutive to view RampID coverage metrics
    * Compare RampID coverage to other identity solutions to establish a baseline
    * Monitor coverage trends over time to identify sudden changes that may indicate technical issues
    * Analyze coverage by user segment (authenticated vs. anonymous, new vs. returning)

    **Optimization strategies:**

    * Implement hashed email collection to significantly boost match rates
    * Ensure your consent UI clearly explains the value exchange for users
    * Work with LiveRamp to understand their recommended best practices for your specific use case
    * Consider implementing progressive registration to gradually collect user data

    <Tip>
      Publishers who collect and pass hashed emails typically see 2-3x higher RampID coverage compared to those relying on probabilistic signals alone.
    </Tip>
  </Accordion>

  <Accordion title="RampID integration conflicts with existing LiveRamp implementation">
    If you already have LiveRamp ATS deployed directly on your site:

    The Permutive RampID integration can coexist with direct LiveRamp implementations, but there may be redundant API calls and potential conflicts. Consider:

    1. **Keep existing implementation:** If your direct LiveRamp integration is working well and meets all your needs, you may not need the Permutive integration
    2. **Migrate to Permutive:** Remove your direct LiveRamp implementation and manage everything through Permutive for:
       * Simplified operations (single dashboard)
       * Reduced JavaScript overhead
       * Unified identity management across all providers
       * Better performance monitoring
    3. **Coordinate with LiveRamp:** Contact LiveRamp support to ensure both implementations are configured optimally if you need both
    4. **Avoid duplicate calls:** Ensure you're not making duplicate API calls for the same user, which can impact performance

    **Performance consideration:** Running duplicate RampID implementations may result in unnecessary API calls and increased page load time. Consolidating to a single implementation is recommended.

    **Migration path:** If migrating from direct integration to Permutive:

    * Disable the direct LiveRamp ATS script
    * Enable RampID in Permutive dashboard
    * Wait for new SDK build
    * Test thoroughly before removing old implementation entirely
  </Accordion>

  <Accordion title="No visible impact on programmatic revenue">
    If you've enabled RampID but haven't seen changes in CPMs or fill rates:

    **Measurement timeframe:**

    * Allow at least 2-4 weeks for measurable impact
    * Programmatic revenue fluctuates naturally; compare equivalent time periods before and after RampID enablement
    * Consider seasonal factors that may affect baseline performance

    **Demand-side adoption:**

    * Not all DSPs and advertisers decrypt and utilize RampID identifiers
    * The value of RampID depends on your specific demand partners and their LiveRamp integrations
    * Contact your SSP or programmatic partners to confirm they support RampID
    * Ask which DSPs in your auctions are actively bidding on RampID-enabled inventory

    **Coverage factors:**

    * Low RampID coverage (percentage of impressions with RampID) will limit revenue impact
    * Review coverage metrics in Permutive Identity Insights
    * If coverage is below 30-40%, consider implementing hashed email collection

    **Analysis approach:**

    * Review Prebid analytics to see bid density changes in auctions with RampID present
    * Compare win rates for bid requests with vs. without RampID identifiers
    * Analyze CPM lift for impressions with RampID vs. without
    * Segment analysis by geography, device type, and user segment
    * Consult with your ad operations team or programmatic partner for detailed analysis

    **Partnership optimization:**

    * Work with LiveRamp to ensure your partnership is properly configured
    * Verify that your inventory is eligible for LiveRamp's demand partnerships
    * Discuss with SSPs about enabling RampID-specific deal IDs or PMPs
    * Consider participating in LiveRamp's publisher monetization programs

    <Note>
      RampID's value proposition varies by publisher based on audience composition, demand partners, email collection rates, and existing identity solutions. Publishers with high email collection rates and strong authenticated audiences typically see the most significant uplift.
    </Note>
  </Accordion>

  <Accordion title="Hashed email format errors or rejection">
    If you're passing hashed emails but RampID isn't recognizing them:

    **Email normalization:**

    * Emails must be lowercase before hashing
    * Remove all leading and trailing whitespace
    * Do not include any additional characters or encoding

    **Correct hashing format:**

    ```javascript theme={"dark"}
    // CORRECT - proper normalization and hashing
    const email = "  User@Example.COM  ";
    const normalized = email.toLowerCase().trim(); // "user@example.com"
    const hashed = await sha256(normalized); // proper SHA-256 hash
    ```

    **Common mistakes:**

    * Using MD5 or SHA-1 instead of SHA-256
    * Hashing the email without normalizing (lowercase, trim)
    * Double-hashing the email
    * Including salt or pepper in the hash
    * Base64 encoding the hash (LiveRamp expects hexadecimal)

    **Verification:**

    * Test your hashing implementation with a known email
    * Use online SHA-256 tools to verify your output matches
    * Check Permutive SDK logs for identifier rejection messages
    * Verify the tag is set to `email_sha256` when calling `identify()`

    <Warning>
      Always hash emails client-side before sending to Permutive. Never send plaintext emails to any third-party service.
    </Warning>
  </Accordion>
</AccordionGroup>

## Changelog

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