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

# Salesforce Marketing Cloud

> Integrate with Salesforce Marketing Cloud for email campaign management and audience activation

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/sfmc.svg?fit=max&auto=format&n=pNhz39ducTVcQczh&q=85&s=762b4e59654ad1226391790a11618216" alt="Salesforce Marketing Cloud" style={{ maxWidth: '32px', maxHeight: '32px', display: 'block' }} width="273" height="191" data-path="images/integrations/logos/sfmc.svg" />
    </div>

    <h3 style={{ margin: 0, fontSize: "1.125rem", fontWeight: "600" }}>Salesforce Marketing Cloud</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="No" />
    </BadgeRowCenter>

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

  <p
    style={{
  margin: 0,
  fontSize: "0.875rem",
  color: "#6b7280",
  lineHeight: "1.5",
}}
  >
    Salesforce Marketing Cloud is a comprehensive digital marketing platform
    that enables publishers to deliver personalized email campaigns and customer
    journeys at scale.
  </p>
</Card>

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

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

## Overview

Salesforce Marketing Cloud (SFMC) is a leading marketing automation platform that helps organizations manage customer relationships and deliver targeted email communications. Our integration with Salesforce Marketing Cloud enables you to activate Permutive cohorts directly into SFMC Data Extensions for use in email campaigns and automated customer journeys.

This integration is a Destination:

* **Destination:** Permutive can activate your cohorts into SFMC Data Extensions, allowing you to target email campaigns with audience segments built in Permutive.

Use cases include:

* Send targeted email campaigns to Permutive cohorts based on user behavior and interests.
* Create personalized customer journeys in SFMC using Permutive audience segments.
* Retarget users via email based on their on-site activity and cohort membership.
* Leverage first-party data from Permutive to enhance email marketing performance.

## Environment Compatibility

| Environment    | Supported    | Notes                                                        |
| -------------- | ------------ | ------------------------------------------------------------ |
| **Web**        | <YesBadge /> | Requires Subscriber Key to be passed via identity management |
| **iOS**        | <YesBadge /> | Requires Subscriber Key to be passed via identity management |
| **Android**    | <YesBadge /> | Requires Subscriber Key to be passed via identity management |
| **CTV**        | <YesBadge /> | Requires Subscriber Key to be passed via identity management |
| **API Direct** | <YesBadge /> | Requires Subscriber Key to be passed via identity management |

## Prerequisites

* **SFMC Account Access** - You must have access to your Salesforce Marketing Cloud account with permissions to create API integrations and manage Data Extensions.

* **SFMC Subdomain** - You must determine the subdomain specific to your Marketing Cloud instance. This can be found in the SFMC dashboard:
  1. Navigate to Administration (under your email address in top-right, where logout is)
  2. Click the General Settings box
  3. Identify the text after "Portfolio Base URL" or "SOAP WSDL" (just the parts between `https://` and the first full stop)
  4. Example: `https://my-subdomain.soap.marketingcloudapis.com/Service.asmx` would be `my-subdomain`

* **Business Unit Configuration** - For each Business Unit you want to send data to, you must configure API integrations in SFMC. You will need:
  * A unique name for each Business Unit (alphanumeric, spaces allowed)
  * Client ID (generated when you create the API integration package)
  * Client Secret (generated when you create the API integration package)
  * An identity type/alias tag that should be synced from Permutive to SFMC

* **Subscriber Key Type** - You must determine whether your SFMC Subscriber Keys are text or numeric values. This configuration is required when setting up the integration in the Permutive dashboard.

* **User ID Alignment** - The IDs being synced to Permutive (via `permutive.identify` in the SDK or API) must match the Subscriber Keys used in SFMC. The Subscriber Key is the primary identifier SFMC uses for contacts, and it must align with the identity type you configure in Permutive.

## Setup

<Tabs>
  <Tab title="Primary Setup Steps">
    <Steps>
      <Step title="Determine SFMC Subdomain">
        Before configuring API access, determine your SFMC subdomain. This is required for the integration setup in the Permutive dashboard.

        1. Log in to Salesforce Marketing Cloud
        2. Navigate to "Administration" (under your email address in top-right, where logout is)
        3. Click the "General Settings" box
        4. Locate the "Portfolio Base URL" or "SOAP WSDL" field
        5. Extract the subdomain (the text between `https://` and the first `.`)
           * Example: `https://my-subdomain.soap.marketingcloudapis.com/Service.asmx` → subdomain is `my-subdomain`

        <Note>The subdomain is consistent across all Business Units in your Marketing Cloud account.</Note>
      </Step>

      <Step title="Configure API Integration for Each Business Unit">
        For each Business Unit you want to activate cohorts to, you must configure API access in Salesforce Marketing Cloud. Repeat these steps for every Business Unit.

        1. In SFMC, navigate to "Installed Packages" under the "Account" dropdown (top-left)
        2. Click the "New" button in the top right
        3. Enter a name and description (e.g., "Permutive \{name-of-business-unit}")
        4. Click "Add Component" and select "API Integration" (should be automatically selected)
        5. Ensure "Perform server-to-server requests" is checked (should be auto-selected)
        6. Scroll down to "Data" section
        7. Under "Data Extensions", grant both "Read" and "Write" permissions
        8. In the new "API Integration" box under "Components", record the following for each Business Unit:
           * **Client ID** - Specific to this Business Unit
           * **Client Secret** - Specific to this Business Unit
           * **Subdomain** - Should match the subdomain you determined in Step 1
        9. Keep these credentials secure and note which Business Unit they correspond to

        <Note>Each Business Unit requires its own API Integration package with unique Client ID and Client Secret credentials.</Note>

        <Tip>If you need to revoke Permutive's access to a specific Business Unit later, delete the corresponding package in "Installed Packages".</Tip>
      </Step>

      <Step title="Enable Integration in Permutive Dashboard">
        Configure the Salesforce Marketing Cloud integration in the Permutive dashboard with your subdomain and Business Unit credentials.

        1. Navigate to the Permutive dashboard
        2. Go to "Settings" → "Integrations"
        3. Find "Salesforce Marketing Cloud" and click "Add Integration"
        4. **Enter your SFMC subdomain** (from Step 1)
        5. **Select Subscriber Key Type** - Choose whether your SFMC Subscriber Keys are "text" or "number"
        6. **Configure each Business Unit** you want to activate cohorts to:
           * **Name** - Enter a descriptive name for the Business Unit (alphanumeric, spaces allowed)
             * This name is used in the Permutive dashboard for reference
             * It's also used in the Data Folder name created in SFMC (e.g., `Permutive (Sales)`)
             * Does not need to match the MID in Marketing Cloud
           * **Client ID** - Enter the Client ID from the API Integration (from Step 2)
           * **Client Secret** - Enter the Client Secret from the API Integration (from Step 2)
           * **Identity Type / Alias Tag** - Specify the identity type that should be synced from Permutive to SFMC
             * This must match the identity you pass via `permutive.identify` in the SDK
             * Example: if you use `permutive.identify([{id: "12345", tag: "sfmc", priority: 0}])`, enter `sfmc` here
        7. To add additional Business Units, click the "+ Business unit" button and repeat the configuration
        8. Click "Save" to complete the integration setup

        <Note>The Identity Type/Alias Tag must match the Subscriber Key you're using in Salesforce. This is how Permutive maps users to SFMC contacts.</Note>
      </Step>

      <Step title="Configure Cohort Activation">
        Once the integration is enabled, you can configure individual cohorts for activation to SFMC.

        1. In the Permutive dashboard, navigate to one of your cohorts
        2. Look for the Salesforce Marketing Cloud activation option
        3. Select the Business Unit you want to send the cohort data to
        4. Set the activation to fire "Every Time" a user enters or exits the cohort
        5. Enable the activation

        When you enable a cohort activation, Permutive will automatically create a Data Extension in SFMC with the same name as your cohort. The Data Extension will be placed in a Data Folder named `Permutive (\{business-unit-name\})`.
      </Step>

      <Step title="Verify Setup">
        In the Salesforce Marketing Cloud dashboard, verify that the integration is working correctly.

        1. Navigate to "Data Extensions" in SFMC
        2. Look for the Data Folder named `Permutive (\{business-unit-name\})`
        3. Inside the folder, you should see Data Extensions corresponding to your activated cohorts
        4. Each Data Extension should contain:
           * `subscriber_key`: The user ID from Permutive
           * `timestamp`: When the user entered the cohort
        5. As users enter and exit cohorts, rows will be added and removed from the Data Extensions

        The Data Extension name will match your Permutive cohort name. The description will contain the cohort code and description (if specified).
      </Step>
    </Steps>
  </Tab>

  <Tab title="Web">
    For web properties, implement identity management using the Permutive Web SDK to pass SFMC Subscriber Keys to Permutive:

    ```javascript theme={"dark"}
    // Identify users with their SFMC Subscriber Key
    permutive.identify([
      {
        id: "subscriber-key-12345", // SFMC Subscriber Key
        tag: "sfmc", // Must match the Alias tag configured in dashboard
        priority: 0
      }
    ]);
    ```

    You should call `permutive.identify()` whenever you have the user's SFMC Subscriber Key available. The Subscriber Key is SFMC's primary identifier for contacts and must match the key used in your SFMC account.

    <Note>The Subscriber Key type (text or number) must be configured correctly in the Permutive dashboard to match your SFMC configuration.</Note>
  </Tab>

  <Tab title="iOS">
    For iOS applications, implement identity management using the Permutive iOS SDK to pass SFMC Subscriber Keys to Permutive:

    ```swift theme={"dark"}
    // Identify users with their SFMC Subscriber Key
    Permutive.shared.identify(
      identifiers: [
        Identifier(
          id: "subscriber-key-12345", // SFMC Subscriber Key
          tag: "sfmc", // Must match the Alias tag configured in dashboard
          priority: 0
        )
      ]
    )
    ```

    You should call `Permutive.shared.identify()` whenever you have the user's SFMC Subscriber Key available.
  </Tab>

  <Tab title="Android">
    For Android applications, implement identity management using the Permutive Android SDK to pass SFMC Subscriber Keys to Permutive:

    ```kotlin theme={"dark"}
    // Identify users with their SFMC Subscriber Key
    Permutive.getInstance().identify(
      listOf(
        Identifier(
          id = "subscriber-key-12345", // SFMC Subscriber Key
          tag = "sfmc", // Must match the Alias tag configured in dashboard
          priority = 0
        )
      )
    )
    ```

    You should call `Permutive.getInstance().identify()` whenever you have the user's SFMC Subscriber Key available.
  </Tab>

  <Tab title="CTV">
    For CTV applications, implement identity management using the relevant Permutive CTV SDK to pass SFMC Subscriber Keys to Permutive.

    The specific implementation will depend on your CTV platform. Use the SDK's identify method to pass the user's SFMC Subscriber Key with the identity type configured in the Permutive dashboard (Alias tag).

    You should call the identify method whenever you have the user's SFMC Subscriber Key available.
  </Tab>

  <Tab title="API Direct">
    For server-side implementations or environments without an SDK, use Permutive's Identify API directly to pass SFMC Subscriber Keys to Permutive:

    ```bash theme={"dark"}
    curl -XPOST https://api.permutive.com/v2.0/identify \
      -H 'X-API-Key: <PUBLIC_API_KEY>' \
      -H 'Content-Type: application/json' \
      -d '{
        "user_id": "<PERMUTIVE_ID>",
        "aliases": [
          {
            "id": "<SFMC_SUBSCRIBER_KEY>",
            "tag": "sfmc",
            "priority": 0
          }
        ]
      }'
    ```

    The `tag` value must match the Alias tag configured in the Permutive dashboard for the relevant Business Unit. You can retrieve your Public API Key from the Permutive dashboard.
  </Tab>
</Tabs>

## Data Types

When you activate a cohort for SFMC, Permutive creates a Data Extension with the following schema:

<AccordionGroup>
  <Accordion title="Data Extension Structure">
    Each Data Extension created by Permutive contains user identifiers and membership timestamps for a specific cohort.

    **Naming Convention:**

    * **Data Extension Name:** Same as your Permutive cohort name (e.g., "Travel Enthusiasts")
    * **Data Extension Description:** Cohort code followed by cohort description (e.g., "12345 - Users interested in travel content")
    * **Data Folder:** All Data Extensions for a Business Unit are organized in a folder named `Permutive ({business-unit-name})` (e.g., `Permutive (Sales)`)
    * **External Key:** Each Data Extension is assigned a UUID as its External Key, which Permutive uses to identify it

    **Fields:**

    <ResponseField name="subscriber_key" type="Text/Number" required>
      The user identifier synced to Permutive that maps to SFMC's Subscriber Key. This is the Alias Tag/Identity Type you configured in the integration setup.

      * Field type matches the Subscriber Key Type configured in Permutive (text or number)
      * Configured as the Subscriber Key attribute in SFMC to make the Data Extension sendable
      * Must match the IDs you pass via `permutive.identify` in the SDK or API
      * Primary Key of the Data Extension
    </ResponseField>

    <ResponseField name="timestamp" type="Date">
      The timestamp when the user entered the cohort in Permutive.

      * Stored without timezone information in SFMC
      * Used to track when users became members of the cohort
    </ResponseField>

    **Behavior:**

    * When a user enters the cohort in Permutive, a row is added to the Data Extension with their `subscriber_key` and entry `timestamp`
    * When a user exits the cohort in Permutive, the corresponding row is removed from the Data Extension
    * Data Extensions are configured as both **sendable** and **testable** for use in email campaigns and automated journeys
    * Segment entries and exits are synced in near real-time (typically within seconds)
  </Accordion>

  <Accordion title="Identity Mapping: Alias Tag and Subscriber Key">
    Understanding the relationship between Permutive's Alias Tag and SFMC's Subscriber Key is crucial for successful cohort activation.

    **What is a Subscriber Key?**

    The Subscriber Key is SFMC's primary identifier for contacts. It's the unique ID that SFMC uses to identify and target individual users across all email campaigns and customer journeys.

    **What is an Alias Tag?**

    In Permutive, an Alias Tag is the name of an identity type. It's how you label different types of identifiers when you call `permutive.identify`. For the SFMC integration, you configure an Alias Tag (e.g., "sfmc") that represents your SFMC Subscriber Keys.

    **How They Work Together:**

    1. You configure the Alias Tag in the Permutive dashboard when setting up the SFMC integration (e.g., "sfmc")
    2. You identify users in Permutive with their SFMC Subscriber Key using this Alias Tag:
       ```javascript theme={"dark"}
       permutive.identify([{
         id: "subscriber-12345",  // The actual SFMC Subscriber Key
         tag: "sfmc",  // The Alias Tag configured in dashboard
         priority: 0
       }]);
       ```
    3. When a user enters a cohort, Permutive looks up their identifier for the configured Alias Tag
    4. Permutive sends this identifier to SFMC as the `subscriber_key` in the Data Extension
    5. SFMC can now use this Data Extension to target the user in email campaigns

    **Important Notes:**

    * The Alias Tag is just a label in Permutive - the actual ID values must be valid SFMC Subscriber Keys
    * The Subscriber Key type (text or number) must be configured correctly in Permutive to match your SFMC setup
    * Users must be identified with the Alias Tag before entering a cohort for activation to work
    * Different Business Units can use different Alias Tags if they use different identifier schemes
  </Accordion>
</AccordionGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Dashboard timeout (500 error) during integration setup">
    If you see a 500 error after approximately 10 seconds when setting up the integration, this is likely due to slow SFMC API response times. The integration should still complete successfully.

    **Solution:**

    * Refresh your browser (hard refresh recommended)
    * Navigate to Settings → Integrations
    * Check if Salesforce Marketing Cloud appears in your list of active integrations
    * If the integration appears, setup was successful despite the timeout
    * If it doesn't appear, try the setup process again
  </Accordion>

  <Accordion title="Unable to enable integration - Permission errors">
    If you receive permission errors when trying to enable the integration, check your API integration configuration in SFMC.

    **Solution:**

    * Verify that you've granted "Read" and "Write" permissions for Data Extensions in your SFMC API Integration package
    * Ensure you're using the correct Client ID and Client Secret for each Business Unit
    * Confirm that the API Integration is set to "Perform server-to-server requests"
    * Check that the subdomain is correct
  </Accordion>

  <Accordion title="Data Extension not being created when activating cohort">
    If a Data Extension is not created when you activate a cohort, there may be a configuration issue.

    **Solution:**

    * Verify that the cohort activation is set to fire "Every Time" (this is the only valid option for SFMC)
    * Check that you've selected a Business Unit for the activation
    * Ensure there are users in the cohort who have been identified with your SFMC identifier type
    * Look for any error messages in the Permutive dashboard when enabling the activation
  </Accordion>

  <Accordion title="Cannot remove or rename Business Unit in dashboard">
    Once a Business Unit is added to the integration configuration, it cannot be removed or renamed through the dashboard. This is a limitation of the integration design.

    **Solution:**

    * Business Units cannot be removed after being added to the integration configuration
    * The name of an existing Business Unit cannot be changed after creation
    * You can edit Client ID, Client Secret, and Alias Tag for existing Business Units, but not the name
    * If you need to remove a Business Unit entirely, contact Permutive Support for assistance
    * To revoke Permutive's access to a specific Business Unit without removing it from Permutive, delete the API Integration package in SFMC's "Installed Packages" section
  </Accordion>

  <Accordion title="Subscriber Key type mismatch">
    If you configured the wrong Subscriber Key type (text vs. number) in the Permutive dashboard, cohort activations may not work correctly.

    **Solution:**

    * Verify the Subscriber Key type in your SFMC account (check if keys are numeric or text-based)
    * The Subscriber Key type configured in Permutive must match your SFMC configuration
    * If you selected the wrong type, contact Permutive Support to update the configuration
    * Check that the IDs you're passing via `permutive.identify` match the expected format (text or number)
  </Accordion>

  <Accordion title="Wrong Business Unit selected for cohort activation">
    If you accidentally activated a cohort to the wrong Business Unit, you can change it.

    **Solution:**

    * In the Permutive dashboard, navigate to the cohort's activation settings
    * Select a different Business Unit from the dropdown
    * The Data Extension will be created in the newly selected Business Unit
    * The old Data Extension in the previous Business Unit will remain but will no longer receive updates
    * To clean up, manually delete the old Data Extension in SFMC if desired
  </Accordion>

  <Accordion title="Users not appearing in SFMC Data Extensions">
    If users in your Permutive cohorts are not appearing in SFMC Data Extensions, there may be an ID mismatch.

    **Solution:**

    * Verify that the IDs being sent to Permutive via `permutive.identify` match the Subscriber Keys in SFMC
    * Check that you've specified the correct identifier type in the integration configuration
    * Ensure users have been identified in Permutive using the identifier type you configured
    * Confirm that the Data Extension's `subscriber_key` column is set as the Subscriber Key attribute in SFMC
  </Accordion>

  <Accordion title="Data Extension moved or renamed - activation stopped working">
    If you've moved or renamed a Data Extension created by Permutive, activations should continue to work.

    **Solution:**

    * Moving Data Extensions to different folders is supported - activations will continue to sync
    * Renaming Data Extensions is supported - activations use the External Key (UUID) to identify the Data Extension, not the name
    * Do NOT change the `External Key` of the Data Extension, as this is used by Permutive to identify the correct Data Extension
    * New activations will still be created in the original Permutive Data Folder
  </Accordion>

  <Accordion title="Timestamps displaying with unexpected timezone">
    Timestamps in SFMC Data Extensions may not display in the timezone you expect.

    **Solution:**

    * Timestamps are stored without timezone information in SFMC
    * The displayed timezone may differ from UTC depending on SFMC's internal handling
    * This is a known limitation and does not affect the functionality of the integration
    * Consider the timestamp as a relative indicator of when users entered cohorts rather than an absolute time
  </Accordion>

  <Accordion title="Can I move, rename, or share Data Folders and Data Extensions?">
    You have flexibility in how you organize Data Folders and Data Extensions created by Permutive in SFMC.

    **Data Folders:**

    * **Moving:** Yes, you can move Data Folders created by Permutive. New Data Extensions will still be placed in the moved folder.
    * **Renaming:** Yes, you can rename Data Folders. New Data Extensions will still be created in the renamed folder.
    * **Sharing across Business Units:** No, Data Folders and Data Extensions cannot be automatically shared across Business Units when created by Permutive. You would need to manually configure sharing in SFMC if needed.

    **Data Extensions:**

    * **Moving:** Yes, you can move Data Extensions to different folders. Activations will continue to sync correctly using the External Key.
    * **Renaming:** Yes, you can rename Data Extensions. Segment transitions will continue to sync because Permutive uses the External Key (UUID) to identify the Data Extension, not the name.
    * **External Key:** Do NOT change the External Key of a Data Extension, as this is how Permutive identifies it for updates.
    * **New activations:** If you move or rename Data Extensions, new cohort activations will still be created in the original Permutive Data Folder.

    **Disabling activations:**

    * Disabling a cohort activation in Permutive will NOT delete the corresponding Data Extension in SFMC
    * You must manually delete Data Extensions in SFMC if you want to remove them entirely
  </Accordion>

  <Accordion title="Can reactions be set up automatically for new segments?">
    No, SFMC cohort activations cannot be automatically enabled when you create a new segment in Permutive.

    **Solution:**

    * You must manually enable the SFMC activation for each cohort you want to sync
    * Navigate to the cohort in the Permutive dashboard
    * Toggle the SFMC activation to "On"
    * Select the Business Unit and configure the activation settings
  </Accordion>
</AccordionGroup>

## Changelog

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