Atlas

Atlas Help Center

New Ticket

Here’a an overview of how to set up Atlas and get the most out of it quickly. We'll cover 7 essential steps to get you started.

Atlas offers multiple channels like chat, email, WhatsApp, SMS, Slack Connect, Discord, Shopify, and customer portal. Many users start with chat.

Atlas chat is a widget you can add to your application or marketing website for users to contact you. It's useful for reporting bugs, asking questions, or submitting support requests. Installation takes just a couple of minutes.

App Configuration > Getting Started > Installation

Add it to your marketing site or application.

If adding to your application, you may want to pass user information to Atlas so it shows who is currently logged in.

After installation, you'll want to configure various aspects of your chat widget, such as:

For more information on these configurations, read our article on 

Receiving emails in Atlas: Set up email forwarding in your provider to send emails to Atlas, where they become tickets.

Replying from your domain: Configure your own sender, like 

For more details on email setup, refer to our 

To quickly see and respond to messages in Slack, go to “

”. Connect your Slack account via OAuth and set up your triage channel. We’ve covered all of this 

To add team members for answering support questions, click on the hamburger menu and go to 

For more information, read our article on managing teammates.

Step 6: Connecting project management tools

To track bugs and feature releases, go to “

” and connect tools like Linear or JIRA.

To pull user data into Atlas, connect your CRM in the integrations section. Atlas will import and continuously update both company and account data

We hope this guide helps you set up Atlas effectively. For any questions, reach out to us at 

Get up and running with Atlas in just a few steps.

Atlas Setup

This guide explains how to install Atlas Chat and Session Recording in your application, regardless of the framework or platform you're using.

There are two main steps in the installation process:

Identifying users (for logged-in experiences)

To begin the installation, Go to the hamburger menu and select “

”. Choose your platform (JavaScript, React, Next.js, mobile, or other web platforms).

For web applications, you'll need to add a piece of JavaScript code to your application. This code snippet is just a few lines long and should be placed in the head of your HTML.

Important: Place this code in a location that's present on every page of your application, such as the root directory or base.html. This ensures the code executes every time a user refreshes or changes pages.

Once you've added the snippet, you should see the Atlas widget appear in your application.

Specific instructions for different frameworks (e.g., Google Tag Manager, React, Next.js, plain JavaScript) are available on the installation page.

The second step is crucial for applications where users can log in. Use the "identify" call method exposed by our JavaScript or mobile SDKs. Pass user information to Atlas through this method.

window.Atlas.call("identify", {
	userId: "User Id",
	name: "User Name",
	email: "User Email",
	fields: {
	    "title": "",
	    "department": "",
	    "photo": "",
	    "accountName": "",
	    "phone": "",
	    "street1": "",
	    "street2": "",
	    "city": "",
	    "country": "",
	    "postalCode": "", 
	    "secondaryEmail": "",
	},
	"customFields": {
    	"tier": "free",
	    "type": "chat",
    	"isGuest": true,
	    "mrr": 1000
  	},
})

The identify call allows you to send various user details to Atlas, including:

While a basic format is provided, you can refer to the full API documentation for details on passing additional fields, such as custom fields or company-level information.

After implementing the identify call, when a user starts a chat, their actual information will appear in the Atlas inbox. For example, you'll see "Chat started by John" instead of a generic user.

If you're installing Atlas on a marketing site where users aren't typically logged in, Atlas will create a widget or dummy user for visitors who initiate a chat.

Atlas supports a wide range of platforms:

Our SDKs (JavaScript SDK for web, Mobile SDK for mobile apps) make integration possible across these diverse platforms.

By following these steps, you should be able to successfully install Atlas Chat and Session Recording in your application. This will enable you to identify users, enhance security, and provide a more personalized support experience.

Learn how to integrate Atlas Chat and Session Recording into your application.

Installing Atlas Chat

(() => {
  "use strict";
  var t,
    e = {
      appId: "YOUR_APP_ID",
      v: 2,
      q: [],
      call: function () {
        this.q.push(arguments);
      },
    };
  window.Atlas = e;
  var n = document.createElement("script");
  (n.async = !0), (n.src = "https://app.atlas.so/client-js/atlas.bundle.js");
  var s = document.getElementsByTagName("script")[0];
  null === (t = s.parentNode) || void 0 === t || t.insertBefore(n, s);
})();

window.Atlas.call("start");

window.Atlas.proxyUrl = 'https://api.yourserver.com/api/v1/atlas_proxy'

Passing customer/company information to Atlas 

To pass customer information to atlas, you can call Identify with the relevant information.  Whenever user is logged into your application, you can make the following call 

  window.Atlas.call("identify", {
    userId: '123',
    name: 'John Doe',
    email: 'john@example.com',
    phoneNumber: '+14153101234'
   })

To make sure scammer can't spoof a user, you should pass a 

here are the other set of fields that you can pass to identify call so your agents have required details to solve tickets. You can set 

 in Atlas to pass any additional fields. 

  window.Atlas.call("identify", {
    userId: '123',
    name: 'John Doe',
    email: 'john@example.com',
    phoneNumber: '+14153101234',
    userHash: '39d97cc77da23fb515d37e6cea066692a799cf85d1330489e2c',
    fields: {
        title: 'CEO',
        department: 'Sales',
        photo: 'https://cdn.filestackcontent.com/2dq5VghRlipv4aWAPAUE',
        street1: '1 main street',
        street2: '#123',
        city: 'San Francisco',
        country: 'US',
        postalCode: '94102',
    },
    customFields: {
        'field1_key': 1,
        'field2_key': 'B',
        'field3_key': '2021-01-23',
    }
})

If you want to pass company information to Atlas, you can pass it in identify call it self.

  window.Atlas.call("identify", {
    userId: '123',
    name: 'John Doe',
    email: 'john@example.com',
    phoneNumber: '+14153101234',
    userHash: '39d97cc77da23fb515d37e6cea066692a799cf85d1330489e2c',
    account: {
        name: 'Acme Inc',
        email: 'support@acmeinc.com',
        website: 'https://acmeinc.com',
        externalId: 'account_id',
        monthlySpend: '999',
        industry: 'Computers',
        customFields: {
          'account_field1_key': '1',
          'account_field2_key': 'A',
          'account_field3_key': '2023-01-12',
        }
    }
})

window.Atlas.call("start", {
  chat: {
    enabled: false
  }
}) 

Start chat when Atlas chat was disabled on startup 

If you want to hide the default atlas chat bubble and give your customer a custom option to start chat by a different button you can use the following options

// Hide the bubble on startup
window.Atlas.call("start", {
  chat: {
    hideBubble: true 
  }
})

Opening Atlas chat when a user clicks a button on your app 

You might have elements in the UI which might blocked by Atlas chat bubble, if you want to add a "Live Chat" or "Contact Support" like button in your UI, which triggers Atlas chat, you can hide the chat bubble by default as shown above and then open the chat window using following method when user clicks on "Contact Support" button.

if you want to hide Atlas chat bubble in some page (like onboarding flow or some public facing part of your app) you can hide the chat bubble using the following method.

To show the Atlas chat bubble agin you can use the following method

If you want to stop Atlas window from auto opening when new agent message comes to Customers, you can pass 

. This is useful if want to show a counter in the UI on unread message instead of auto opening the widget.

window.Atlas.call("start", {
  chat: {
    hideBubble: true, 
    openIncoming: false
  }
})

window.Atlas.call("start", {
  chat: {
    hideBubble: true, 
    openIncoming: false,
    onNewAgentMessage: (message) => {
      console.log(message);
    },
    onWindowVisibilityChange: (visible) => {
      console.log(visible)
    }
  }
})

Atlas.call('showNewChat', { text: 'Hello' })

With SDK you should be able to control position and offset of your chat bubble, here are the options

window.Atlas.call("start", {
    chat: {
        'position': 'bottomLeft',
        'offset': [20, 21]
    }
});


If you are using layout menu and want to add a option that triggers some workflow in your app, you can use that as a callback option. To register a call back with Atlas, you could do the following

window.Atlas.call("start", {
    callbacks: {
        hello: () => alert('hello!')
    },
})

If you want to update position of chat dynamically or switch colors, you can update any of the configuration using the 

window.Atlas.call('update', {
    'chat': { 
        'position': 'bottomLeft',
        'offset': [80, 21]
    }
});

Controlling chat visibility based on location 

If you want to limit visibility of your chat to certain country or hide it from certain country, you can use the following methods

Atlas.call('start', {
    access: { countries: ['US'] },
})

Atlas.call('start', {
    access: {
        countries: ['US'],
        inverseCountries: true,
    },
})

Atlas.call('start', {
  chat: {
    brandColor: 'linear-gradient(180deg, pink 0%,gold 84%)', // or color '#ff0000'
    textColor: 'light', 
    launcher: {
      label: 'Welcome', 
    },
    widget: {
      title: 'H1',
      subtitle: 'H2',
      // can be the http(s) url as well
      logo: 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==', 
    },
  },
})

If selectively want to control on which pages session should be recorded, you can control it using the follow options

window.Atlas.call("start", {
  recording: {
    enabled: false
  }
})

Start session recording on specific pages/paths

 Stop session recording on specific pages/paths

If you want to get the current session id so you can pass it a APM or error monitoring tools like sentry, you can get it using following method

 about how to to hide/mask certain information from getting recorded.

To open up a help center category in chat widget

window.Atlas.call('openArticlesCategory', 'category')

To show an helpcenter article article directly in chat widget, you can use the following method

window.Atlas.call("openArticle", {
    "slug": "703242-session-recording"
});

window.Atlas.call('openArticlesSearch', 'how to setup helpcenter')

 you may want to open specific one for your user conditionally:

window.Atlas.call("triggerChatbot", "CHATBOT_KEY");

 is a string that you can find in the Chatbot Setup window. When you navigate to your Chatbot graph click the entry block and you will find the "Chatbot Key" field in the opened modal window.

Ensure that in the Chatbot Setup window the "Start Conversation" is set to "Via SDK" to make it available for 

Javascript SDK configuration and methods

Preventing user impersonation is key to protecting your users’ information. To do so, we allow you to create an encrypted user hash that we use to determine whether or not a user communicating with your team is the user they claim to be.

Authentication is fairly straightforward. On your server, take information that only you have access to (i.e., your secret key), combine it with a unique identifier for the user (i.e., their user id) and then run it through a hashing function (HMAC 256) to create an encrypted value (

). Send it to the client who will then send it to Atlas whenever they engage with our app. Using your secret key, we decrypt the 

 and determine whether or not the user is the same as the one they claim to be.

To enable user authentication within Atlas, go to 

To setup user authentication, you need to create a hashed_value on your server and then pass it to Atlas via Javascript using the 

Here’s an example of how you would create the userHash on the backend using Python

import hashlib
import hmac

def _get_atlas_userhash(user_id):
    secret = config['ATLAS_USER_HASH_KEY']
    key = secret.encode('ascii')
    message = str(user_id).encode('ascii')
    return hmac.new(key, message, hashlib.sha256).hexdigest()


import { createHmac } from "crypto";

export const generateAtlasUserObject = (user: User) => {
  if (!user) {
    return {};
  }
  const atlasSecret = process.env.ATLAS_SECRET || "";
  const hmac = createHmac("sha256", atlasSecret);
  hmac.update(user.id);
  const userHash = hmac.digest("hex");
  return {
    userId: user.id,
    name: user.name,
    email: user.email,
    userHash,
  };
};

 For other languages, you find an example 

And on the front end, you would pass this information to Atlas as follows:

window.Atlas.call("identify", {
   userId: this.user.id,
   name: this.user.name,
   email: this.user.email,
   userHash: this.user.atlasHash,
})

 and enable Authentication by enabling  "Authenticate Users".

After authentication is enabled, atlas chat won't start for anyone trying to spoof a user. 

User Authentication

Atlas supports a variety of communication channels to help you connect with your customers wherever they are. From real-time chat to asynchronous messaging, we've got you covered. Let's explore the different channels available and how they can enhance your customer support experience.

Atlas currently supports the following communication channels:

Engage with customers in real-time directly on your website. Customize your chat widget to match your brand and provide instant support.

Handle customer inquiries through email, keeping all communications organized and easily accessible within Atlas.

Reach customers on their mobile devices with text messaging support, perfect for quick updates and notifications.

Connect with customers on one of the world's most popular messaging platforms, offering rich media support and end-to-end encryption.

Collaborate with your team and manage customer support directly within Slack, streamlining your internal communications.

To manage your communication channels, go to 

. Here you can configure each channel according to your specific needs and preferences.

Yes, you can enable and use all supported channels simultaneously in Atlas.

How do I prioritize messages from different channels?

Atlas allows you to set up custom routing and prioritization rules for messages across all channels. Check our routing documentation for more details.

Atlas is continually expanding its channel support. Keep an eye on our updates for new channel integrations.

Provide seamless support across multiple platforms.

Configuring different channels

This guide will walk you through setting up Slack Triage, allowing you to communicate with customers and handle internal discussions directly from Slack.

". Click the blue "connect" button, select your Slack workspace and allow Atlas to connect to your workspace.

After connecting, you'll be redirected back to Atlas with additional options. You can:

Enable access to private channels (optional)

Select specific channels for Slack Triage

Choose which ticketing channels to receive updates from (all are enabled by default)

For configuring the triage channel, ensure you've selected the correct workspace. Choose a specific channel for triaging (e.g., "support") and save your settings.

Once set up, here's how Slack Triage works:

New tickets appear as threads in your chosen Slack channel

To respond to a customer, type "atlas" followed by your message

For internal notes, simply type your message without mentioning Atlas

New messages from customers will create new threads in the channel

With slack triage, you can assign tickets to team members directly from Slack. change ticket priority and send canned responses.

, select the appropriate response from the list. It will be sent to the customer as if you typed it yourself.

Check your designated Slack channel for the new thread

Try responding by adding "@atlas" at the start of your message

Send an internal note without the "atlas" prefix

Verify that the responses appear correctly in both Slack and Atlas

Slack Triage allows you to manage your support workflow efficiently without leaving Slack. You can respond to customers, collaborate with your team, and manage tickets all from one interface.

If you have any questions about setting up or using Slack Triage, please contact us at 

Manage your tickets directly from Slack without leaving the interface.

Setting up Slack Triage

This guide will walk you through the process of adding team members and explain the different roles available.

Inviting teammates to Atlas is a straightforward process.

Begin by opening the hamburger menu and click on Settings > Team. You'll find the option to add a teammate. Click on this option to start the invitation process.

Enter the name and email address of the person you want to invite. Next, select the appropriate role for your new team member. After filling in all the necessary information, simply click "Save" to send out the invitation.

Atlas offers different roles to suit various team needs.

The admin role is designed for those who need full control over Atlas settings and can manage all aspects of the platform. Agents, on the other hand, can communicate with clients and handle support tickets, but have limited access to settings.

For team members who need to access and view data without communicating with clients, the viewer role is ideal. This role is perfect for engineers, product managers, or operations staff who need insight into customer interactions without direct involvement.

It's worth noting that Atlas doesn't charge for viewer seats, making it a cost-effective option for larger teams.

Once you've invited your teammates, Atlas provides several options for managing your team. You can resend invitations if needed, change a team member's role as their responsibilities evolve, or disable a team member's account if they leave the team or take a break.

Set up your team for collaborative customer support.

Inviting teammates

This guide explains how to integrate your project management tool with Atlas, using Linear as an example. This integration allows for seamless ticket management between your support and development teams.

To set up the integration, start by clicking on 

Choose your project management tool, in this case, Linear.

Click on "Connect Linear," and you'll be directed to authorize the connection.

Once authorized, you'll be returned to Atlas where you can configure the integration settings.

The integration settings allow you to customize how Atlas and your project management tool interact. Here are the key areas to configure.

This setting determines which teams your support agents can create tickets for. You can choose to give access to all teams or restrict it to specific departments like engineering or sales.

This crucial setting defines how tickets move between Atlas and your project management tool. For example, when a support ticket in Atlas is linked to a Linear issue, you might want to move the Atlas ticket to a pending or snoozed status. You can then set up rules to automatically reopen the Atlas ticket when the linked Linear issue is completed or cancelled.

You can choose what information gets synced between Atlas and your project management tool.

For Atlas to Linear sync, you might want to update the Linear ticket when there are changes in priority, assignee, tags, or when new messages or notes are added in Atlas.

For Linear to Atlas sync, you can choose to update the Atlas ticket when there are changes in the Linear ticket's priority, status, or when new comments are added.

Once set up, you can easily link Atlas tickets to issues in your project management tool. Here's how it works:

In an Atlas ticket, press Shift+L or use the menu to link a Linear issue.

You can create a new issue or link to an existing one.

Once linked, you can move the Atlas ticket to pending status if needed.

When the linked issue in Linear is marked as done, the Atlas ticket will automatically reopen, allowing you to inform the customer.

The integration also ensures that relevant updates in either system are reflected in the other, keeping your support and development teams in sync.

This integration helps streamline your workflow, ensuring that support tickets related to development issues are properly tracked and resolved, and that your support team is promptly notified when issues are addressed.

Streamline your workflow by connecting Atlas with your project management tool.

Project management tool integration

CRM integrations allow you to synchronize data between your Customer Relationship Management system and Atlas, providing your support team with crucial customer information and keeping your sales team informed about support activities.

CRM integration serves two main purposes.

This gives your support agents access to important customer information, such as Annual Contract Value (ACV), helping them prioritize and personalize their support.

This keeps your sales team informed about ongoing support issues, which can be crucial during customer interactions like renewal discussions.

When you connect Atlas to your CRM, the following information is typically synchronized:

Contacts: Individual customer information

Notes: Any additional information associated with contacts or companies

Ticket activities: Support interactions from Atlas can be synced to the CRM

Atlas currently supports integration with:

We are continually working on adding support for more CRM systems.

To set up CRM integration, go to the app configuration section in Atlas and select your CRM system (HubSpot, Salesforce, or Close). Follow the specific installation instructions for your chosen CRM

Detailed setup guides for each supported CRM are available in 

Support agents can see valuable customer information like ACV directly in Atlas, allowing them to provide more personalized support.

Better alignment between support and sales

Account managers can see pending support tickets in the CRM, helping them communicate more effectively with customers during sales interactions.

By syncing data between systems, you ensure that both your support and sales teams have access to the most up-to-date customer information.

Reduce the need for your team to switch between multiple systems to gather customer information.

Getting Started

Getting Started articles