Atlas

Atlas Help Center

New Ticket

Connect Atlas with Sentry to streamline error tracking and enhance your support workflow.

Sentry integration with Atlas allows you to seamlessly incorporate error tracking into your support process. This powerful connection enables your support team to quickly identify and address application errors, leading to faster issue resolution and improved customer satisfaction.

Let's explore how to set up and use this integration.

App configuration > Integrations > Sentry integration.”

You'll be redirected to the Sentry authorization page. If you're already logged into your Sentry account, simply click "Accept" to grant Atlas access.

Choose the Sentry projects you want to connect with Atlas. Click "Save" to finalize the integration.

Once the integration is set up, you'll see Sentry data incorporated into your Atlas workflow:

When an application error occurs, you'll see a notification in Atlas that looks like this:

The notification will include the Sentry logo and a "Bug encountered" message.

Clicking on the error notification will redirect you to the corresponding Sentry issue. This allows your support agents to quickly access detailed error information without leaving their support workflow.

Support agents can use this error data to:

Identify if a customer's issue is related to a known bug

Provide more accurate and timely responses to customers

Collaborate more effectively with the development team on issue resolution

1.Can I connect multiple Sentry projects to Atlas?

Yes, you can connect multiple projects from your Sentry organization to Atlas.

2.Will all Sentry errors appear in Atlas?

The integration will show errors from the Sentry projects you've selected during the setup process.

3.Can support agents create Sentry issues from Atlas?

Currently, the integration is focused on displaying Sentry data in Atlas. Creating Sentry issues directly from Atlas is not supported at this time.

Sentry integration

To configure the internal dashboard, set the URL to the URL of an individual customer in your internal tool (e.g. 

https://www.myapp.com/admin/user?user_id={user_id}/

You can use variables in the URL by wrapping them in curly brackets (e.g., 

). You can use the following variables in your URL:

In order for your internal dashboard to be visible within Atlas, the page needs to allow embedding. To check for this, ensure that the HTTP response from your server:

(if you are using cookie based authentication)

If this is not set correctly, you’ll see an error that looks like:

' because an 
ancestor violates the following Content Security Policy 
directive: "frame-ancestors 'self'".

 header via your application server. Here are some examples for some of the most common servers:

Header set Content-Security-Policy "frame-ancestors 'atlas.so';"

add_header Content-Security-Policy "frame-ancestors 'atlas.so';";

 to the end to ensure that nginx sends the header regardless of response code.

You can use the HTTP Response Headers GUI in IIS Manager or add the following to your web.config:

<system.webServer>
  <httpProtocol>
    <customHeaders>
      <add name="Content-Security-Policy" value="frame-ancestors 'atlas.so';" />
    </customHeaders>
  </httpProtocol>
</system.webServer>

 header, you can extend it by adding value after semicolon (

 value, you can safely extend it by adding only 

If you are using cookie based authentication, then you will have to set the 

 attribute of the auth cookie to None so the cookie is accessible in Atlas UI.

from flask import Flask, make_response

app = Flask(__name__)

@app.route('/')
def hello_world():
    resp = make_response('Hello, World!');
    resp.set_cookie('same-site-cookie', 'foo', samesite=None);

Internal Dashboard

Sync your customer data from Segment to Atlas for enhanced support and analytics.

Segment integration with Atlas allows you to seamlessly forward customer events and properties from your Segment CDP to Atlas. This powerful connection enables you to leverage rich customer data for more personalized and efficient support.

*App configuration > Integrations > Segment

”*. You'll find two crucial pieces of information:

These will be used in the Segment configuration process.

To forward data from Segment to Atlas, you'll need to set up a custom function in Segment.

In your Segment dashboard, navigate to Functions. Create a new function

Copy and paste the provided Atlas script into the function:

// Token is available at https://app.getatlas.io/configuration/integrations/segment
const SEGMENT_TO_ATLAS_TOKEN = '';

const BASE_URL = 'https://api.atlas.so';
const API_VERSION = 'v1';

async function onIdentify(event, settings) {
    const endpoint = `${BASE_URL}/${API_VERSION}/customers/upsert`;

    if (!event.userId) {
        throw new EventNotSupported('Mandatory parameters are missing');
    }

    if (!SEGMENT_TO_ATLAS_TOKEN) {
        console.log('Bad Configuration - SEGMENT_TO_ATLAS_TOKEN - missing');
        return;
    }
    
    let firstName;
    let lastName;

    let fullName = event.traits.name;
    
    if (fullName) {
        firstName = fullName.split(' ')[0];
        lastName = fullName.substring(firstName.length).trim()
    } else {
        firstName = event.traits.firstName || event.traits.first_name
        lastName = event.traits.lastName || event.traits.last_name
    }

    const payload = {
        userId: event.userId,
        email: event.traits.email,
        firstName: firstName,
        lastName: lastName,
    };

    if (event.traits.phone) {
        payload['phoneNumber'] = event.traits.phone
    }

    if (event.traits.company) {
        const accountData = {
            name: event.traits.company.name,
            website: event.traits.company.domain,
            externalId: event.traits.company.id,
        };
        payload['account'] = accountData;
    }

    try {
        response = await fetch(endpoint, {
            method: 'POST',
            headers: {
                Authorization: `Bearer ${SEGMENT_TO_ATLAS_TOKEN}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(payload)
        });

        if (response.status >= 300) {
            throw new RetryError(`Failed with ${response.status}`);
        }
    } catch (error) {
        throw new RetryError(error.message);
    }
}

async function onTrack(event, settings) {
    const endpoint = `${BASE_URL}/${API_VERSION}/events`;
    let response;

    if (!event.userId) {
        throw new EventNotSupported('Mandatory parameters are missing');
        return;
    }

    if (!SEGMENT_TO_ATLAS_TOKEN) {
        console.log('Bad Configuration - SEGMENT_TO_ATLAS_TOKEN - missing');
        return;
    }

    const atlasEvent = {
        objectType: 'CUSTOMER',
        objectId: event.userId,
        name: 'Event Tracked',
        description: event.properties.title || '',
        payload: {
            ...event.context,
            ...event.properties
        }
    };

    try {
        response = await fetch(endpoint, {
            method: 'POST',
            headers: {
                Authorization: `Bearer ${SEGMENT_TO_ATLAS_TOKEN}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(atlasEvent)
        });

        if (response.status >= 500 || response.status === 429) {
            throw new RetryError(`Failed with ${response.status}`);
        }
    } catch (error) {
        throw new RetryError(error.message);
    }
}

async function onPage(event, settings) {
    const endpoint = `${BASE_URL}/${API_VERSION}/events`;
    let response;

    if (!event.userId) {
        throw new EventNotSupported('Mandatory parameters are missing');
        return;
    }

    if (!SEGMENT_TO_ATLAS_TOKEN) {
        console.log('Bad Configuration - SEGMENT_TO_ATLAS_TOKEN - missing');
        return;
    }

    const atlasEvent = {
        objectType: 'CUSTOMER',
        objectId: event.userId,
        name: 'Page Viewed',
        description: event.properties.title || '',
        payload: {
            ...event.context,
            ...event.properties
        }
    };

    try {
        response = await fetch(endpoint, {
            method: 'POST',
            headers: {
                Authorization: `Bearer ${SEGMENT_TO_ATLAS_TOKEN}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(atlasEvent)
        });

        if (response.status >= 500 || response.status === 429) {
            throw new RetryError(`Failed with ${response.status}`);
        }
    } catch (error) {
        throw new RetryError(error.message);
    }
}

async function onGroup(event, settings) {
  const endpoint = `${BASE_URL}/${API_VERSION}/accounts/upsert`;

  if (!event.userId) {
    throw new EventNotSupported("Mandatory parameters are missing");
  }

  if (!SEGMENT_TO_ATLAS_TOKEN) {
    console.log("Bad Configuration - SEGMENT_TO_ATLAS_TOKEN - missing");
    return;
  }

  const payload = {
    externalId: event.groupId,
    name: event.traits.name,
    email: event.traits.email,
  };

  try {
    response = await fetch(endpoint, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${SEGMENT_TO_ATLAS_TOKEN}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(payload),
    });
    if (response.status >= 300) {
      throw new RetryError(`Failed with ${response.status}`);
    }
  } catch (error) {
    throw new RetryError(error.message);
  }
  
}

Customize the script as needed to match your event structure.

The exact steps and script are detailed in our Segment configuration guide, which you can access from the integration page.

Once configured, Segment will forward events to Atlas as custom events. This means:

-All data sent from Segment will appear in Atlas under the custom events section

-You can use this data to trigger automations, enrich customer profiles, or provide context during support interactions

-The structure of these custom events will depend on how you've set up your Segment tracking and the customizations made to the forwarding script

Introduction and instructions for setting up connection with Segment

Segment Integration

Seamlessly integrate your Dialpad calls with Atlas for comprehensive customer support tracking.

Dialpad integration with Atlas allows you to monitor incoming and outgoing calls, track customer interactions, and streamline your voice support workflow. This powerful connection enables your team to maintain a complete record of customer communications across all channels.

To connect Dialpad with Atlas, go to ”

*App configuration > Integrations > Dialpad integration

”.* You'll see a field to enter your Dialpad API key.

Generate an API key by following the instructions in the Dialpad documentation (linked on the integration page). Enter the API key and click "Save".

Once saved, Atlas will establish a connection with Dialpad and begin monitoring call events.

Atlas tracks various call states, including:

Atlas identifies customers based on their phone number and creates appropriate records for each call.

Unlike some other integrations, Dialpad allows Atlas to monitor outgoing SMS messages as well as calls.

Enable the "Sync contacts" option to automatically create Dialpad contacts for customers in Atlas.

You can customize how Atlas responds to different call outcomes:

Under "Call behavior", you'll see options for different call states (answered, missed, outbound)

For each state, choose one of the following actions:
 

This allows you to tailor the integration to your support workflow. For example, you might want missed calls to automatically create new conversations for follow-up.

1.Can I see call transcriptions in Atlas?

If Dialpad provides a transcription for a voicemail, this will be included in the Atlas record.

Outbound calls are logged as custom events or conversations (based on your configuration) regardless of whether they were answered.

3.Can I link existing Atlas customers with their Dialpad records?

Yes, Atlas automatically links customers based on phone numbers. You can also manually link records if needed.

Dialpad integration 

Atlas offers seamless integration with HubSpot, allowing you to synchronize customer data between your CRM and support platform.

App Configuration > Integrations > Hubspot

If you're already logged into your HubSpot account, the connection process will be smoother. After clicking "Connect", follow the prompts to authorize the integration.

Note: Only one CRM integration can be active at a time, so ensure you want to use HubSpot before proceeding.

Once connected, you'll need to configure the integration to ensure proper data mapping between HubSpot and Atlas.

Start by mapping core fields such as first name, last name, primary email, primary phone, and ID. This mapping is crucial to prevent duplicate customer records between the two systems.

Atlas allows you to map custom fields from HubSpot to custom fields in Atlas. In the left-hand dropdown, you'll see all custom fields from HubSpot. On the right, you'll see custom fields you've created in Atlas for the customer entity. Map these fields according to your business needs.

Similar to customer mapping, you can also map account fields between HubSpot and Atlas.

You can set up activity syncing between HubSpot and Atlas. For example:

Calls or notes created in HubSpot can be synced as custom events in Atlas.

Conversations or customer notes created in Atlas can be made visible in HubSpot.

This two-way sync ensures that both your support and sales teams have access to the most up-to-date customer information.

Synchronize data between Atlas and Hubspot.

Hubspot integration

Atlas offers a powerful integration with Close CRM, allowing you to synchronize customer data between your sales and support platforms. This integration helps create a unified view of your customers, enabling more efficient and personalized support.

Click on "Connect to Close" and log in to your Close account if you're not already authenticated. Follow the prompts to authorize the integration.

Note that Atlas only allows one active CRM integration at a time, so make sure Close is your preferred CRM before proceeding.

After connecting, you'll need to set up the data flow between Close and Atlas.

Start by linking basic information like names, emails, and phone numbers. This ensures consistency and prevents duplicate records across both systems.

You can map custom fields from Close to Atlas. This allows you to sync specific data that's important to your business processes.

Link Close leads and contacts to corresponding entities in Atlas to maintain a consistent view of your customers across both platforms.

Set up two-way activity syncing between Close and Atlas:

Activities in Close (like calls, emails, or tasks) can appear as events in Atlas.

Conversations or notes created in Atlas can be reflected in Close.

This keeps both your sales and support teams informed about all customer interactions.

Streamline your sales and support processes with seamless data sync.

Close integration

Bring your sales and support data together for better customer service.

Atlas works smoothly with Salesforce, letting you sync customer info between your CRM and support tool. This helps you see a full picture of your customers and provide better, faster support.

App Configuration > Integrations > Salesforce

Click "Connect to Salesforce" and log in to your account. Follow the steps to allow the connection.

Remember, you can only use one CRM with Atlas at a time. Make sure Salesforce is the one you want.

After connecting, you'll set up how data moves between Salesforce and Atlas.

Link up basic info like names, emails, and phone numbers. This helps avoid duplicate records and keeps info consistent.

You can also link custom fields from Salesforce to Atlas. This lets you sync the specific data that matters to your business.

Link Salesforce objects (like Accounts or Opportunities) to similar items in Atlas.

Things logged in Salesforce (like calls or tasks) can show up in Atlas.

Conversations or notes in Atlas can appear in Salesforce.

This keeps your support and sales teams up to date.

Connecting Salesforce and Atlas has many perks:

See the whole picture: Support agents get helpful Salesforce data right in Atlas.

Solve issues faster: More info means quicker solutions.

Sales and support work better together: Sales can see support interactions, and vice versa.

Spot VIP customers: Easily see high-value customers for better service.

Keep everything current: Both systems stay up to date automatically.

Better reporting: Combine support and sales data for smarter insights.

Salesforce integration

Connect your support and development workflows seamlessly with Linear integration.

Linear integration with Atlas bridges the gap between customer support and development teams. This connection allows for effortless creation of development tasks from support tickets, ensuring faster issue resolution and improved cross-team collaboration.

App configuration > Integrations > Linear integration

. You'll be prompted to authorize the connection with your Linear account.

Once connected, you'll see settings for configuring the integration:

Choose which Linear teams you want to monitor. You can select all teams or focus on specific ones relevant to customer support issues.

Set up rules for automatically updating Atlas tickets based on Linear issue status changes. For example, you might want to move an Atlas ticket to "Pending" when the corresponding Linear issue is marked as "In Progress".

Choose which activities to sync between Linear and Atlas. This could include priority changes, status updates, and comments.

Once set up, the Linear integration enables several useful features.

Creating Linear issues from Atlas tickets

When viewing a ticket in Atlas, you can create a linked Linear issue directly from the ticket interface. This creates a two-way connection between the support ticket and the development task.

Atlas will display Linear activities related to the linked issue. This allows support agents to see development progress without leaving the Atlas interface.

Changes to the Linear issue status can automatically update the Atlas ticket status, keeping everyone informed of progress.

Linear integration

Enhance your voice support with seamless Aircall and Atlas integration.

Aircall integration with Atlas allows you to monitor incoming and outgoing calls, track customer interactions, and streamline your voice support workflow. This powerful connection enables your team to maintain a complete record of customer communications, improving your overall support experience.

To connect Aircall with Atlas, navigate to “

*App configuration > Integrations > Aircall

”*. You'll see a field to enter your Aircall API key.

Generate an API key by following the instructions provided in the Aircall documentation, which is linked on the integration page.

Once you've entered the API key, click "Save" to establish the connection between Aircall and Atlas.

Atlas tracks various call states for your Aircall interactions. These include ringing, answered, unanswered, and voicemail-related states. When a call comes in, Atlas monitors these events and creates appropriate records based on the outcome.

Using the caller's phone number, Atlas identifies the corresponding customer in your database. If a matching customer is found, the call information is associated with their profile. If no match is found, a new customer record can be created based on your configuration settings.

You can configure how Atlas responds to different call outcomes. In the Aircall integration settings, you'll find options to customize actions for answered calls, missed calls, and outbound calls.

For each of these scenarios, you can choose to create a custom event, start a new conversation, or create a closed conversation. This flexibility allows you to tailor the integration to your specific support workflow and priorities.

To customize how Atlas handles different call outcomes, go to the Aircall integration settings. Under the "Call behavior" section, you'll see options for answered calls, missed calls, and outbound calls. For each of these, you can select one of the following actions:

This is the default behavior. It logs the call as a custom event in the customer's timeline.

This creates a new open conversation in Atlas, which can be assigned to an agent for follow-up.

This creates a conversation record but sets it to a closed state, useful for logging purposes without cluttering the active queue.

If Aircall provides a transcription for a voicemail, this will be included in the Atlas record.

Outbound calls are logged based on your configuration settings, regardless of whether they were answered or not.

3.Can I link existing Atlas customers with their Aircall records?

Aircall integration

Streamline your support and development workflows with seamless Jira integration.

Jira integration with Atlas connects your customer support and development teams, allowing for efficient issue tracking and resolution. This integration enables you to create Jira issues from support tickets, sync updates, and maintain clear communication between teams.

Let's explore how to set up and use this powerful integration.

*App configuration > Integrations > Jira integration

. You'll be directed to Atlassian, where you'll need to grant the necessary permissions for the integration.

Once connected, you'll see a settings page with various options:

Choose which Jira projects you want to monitor. You can select all projects or focus on specific ones relevant to customer support issues.

For example, you might want to monitor only your "Customer Support" and "Bug Fixes" projects in Jira.

Configure how Atlas ticket fields map to Jira issue fields. This ensures that important information is transferred correctly when creating issues.

Once set up, the Jira integration offers several useful features:

When viewing a ticket in Atlas, you can create a linked Jira issue directly from the ticket interface. This creates a two-way connection between the support ticket and the development task.

Atlas will display Jira activities related to the linked issue. This allows support agents to see development progress without leaving the Atlas interface.

Changes made in either Atlas or Jira are reflected in both systems. This keeps your support and development teams aligned without manual updates.

Jira integration

Connect Atlas with Slack to streamline your support workflow and enhance team collaboration.

Slack integration with Atlas allows you to manage support tickets directly from your Slack workspace. This powerful integration enables triaging, ticket creation, and support directly within Slack, making your team more efficient and responsive.

App configuration > Integrations > Slack integration

. You'll be directed to authorize the Atlas app in your Slack workspace.

Once connected, you'll see several configuration options:

Choose which Slack channels Atlas should monitor. You have three options:

All internal channels (except private channels)

Select the option that best fits your workflow. Remember, private channels are always excluded to maintain privacy.

Decide how you want to use Slack with Atlas:

Triaging only: Use Slack just for ticket triaging

Triaging and support: Enable full support capabilities in Slack Connect channels

Choose the option that aligns with your support strategy.

Once set up, the Slack integration offers several powerful features:

Incoming support requests are forwarded to your designated triaging channel. From there, you can set priorities, change assignees, and manage tickets directly in Slack.

If enabled, you can provide direct support in Slack Connect channels. These conversations are synced with Atlas, maintaining a complete support history.

For full functionality, agents need to link their Slack accounts with Atlas. Go to 

Slack integration

Learn how to connect your internal dashboards to Atlas for a seamless agent experience.

Atlas allows you to integrate your internal dashboards directly into the platform. This feature helps reduce context switching for agents, allowing them to access important information without leaving the Atlas interface.

The internal dashboard integration in Atlas works by allowing you to embed your existing dashboards using a URL-based system. You can pass specific variables from Atlas to your dashboard, ensuring that the displayed information is relevant to the current context.

To integrate your internal dashboard, go to “

App Configuration > Integrations > Internal dashboard

”. You'll see a field where you can paste your dashboard URL.

Atlas provides a comprehensive set of variables that you can use in your dashboard URL. These variables allow you to pass context-specific information to your dashboard. Some examples include:

The exact list of available variables is documented within Atlas, ensuring you have access to all the information you might need.

Integrations