# Best Practices: Optimizing Your Email Outreach
Source: https://docs.unifygtm.com/best-practices/deliverability
## Sequence Copy
1. **Keep an individual sequence to 4 email touches max -** Within a four-touch sequence, we recommend alternating the structure between 2 new threads and 2 follow-up replies. The copy of these follow-up replies can be short and limited to 1-2 sentences. Example: "Any thoughts on my previous note?"
2. **Alternate case studies and value props between new threads -** You should vary the copy and angle you're approaching to pitch your product in email steps 1 and 3. For example, you can highlight different customer case studies or statistics across both emails.
3. **Shorten subject line and use personalization -** Keep subject titles concise and add custom variables to increase variability. This approach will also help improve deliverability. Example: "Unify x (Your Company Name)"
4. **Include statistics and case studies for social proof -** Incorporating very numbers-driven, concise impact statements can catch your prospect's attention. We recommend adding concise blurbs from customer case studies into your sequence copy.
5. **Add personalization with snippets -** You can use Unify's smart snippets to personalize copy based on relevant value prop, job title, work description, industry, and more. This will make your sequence copy more compelling with targeted pain points, use cases, or case studies. More variance in email copy will also help with deliverability.
6. **Keep it concise, focus on a single product or pain point -** Don't try to fit too many points into your email - you want to be decisive and mention the most relevant product or pain point to that individual to capture their attention! Keep the language simple and avoid business jargon. We generally recommend keeping each email between 50-200 words.
7. **End with a compelling call to action (CTA) -** Conclude each email with a clear, specific, and actionable request. This could include scheduling a call, booking a demo, or asking the prospect to reply with a specific piece of information relevant to their needs.
## Deliverability
1. **Limit the links -** Try not to overload your emails with multiple or duplicate links. Too many links can set off spam alarms - we generally recommend limiting the email touch to include 1-2 links maximum.
2. **Check link safety -** Ensure the links you include are secure and no warnings are displayed by the browser when visiting them.
3. **Mix up subject lines -** Don't stick with the same old subject lines, use template variables to keep them dynamic and interesting.
4. **No all caps -** Using all caps anywhere in your email can make it look spammy, so stick to normal capitalization.
5. **Easy on the exclamation -** Too many exclamation points can trigger spam filters, especially in the subject line. Use them sparingly!
6. **Send from multiple email addresses -** Sending emails from multiple mailboxes improves deliverability by distributing volume across different IP addresses and domains. This approach reduces the risk of being flagged as spam and increases overall sending capacity.
7. **Proofread for Typos**: Typos can make your email look unprofessional, especially when you're emailing multiple contacts at a company. Make sure to proofread and catch any errors.
# Best Practices
Source: https://docs.unifygtm.com/best-practices/introduction
Unify's recommendations for high-performance GTM.
Learn how to use plays effectively to automate your outbound.
Design your sequences to maximize response rates and deliverability.
# Best Practices: Plays to Book You Meetings
Source: https://docs.unifygtm.com/best-practices/plays
## Section 1: Best Practices
Unify is a sales engagement platform designed to help you generate pipeline. To ensure that you see the best results, we recommend a few general principles:
* **Act Quickly:** Act on intent signals within 24-48 hours to catch prospects before they make their decision. Intent gets stale quickly.
* **Engage with Every Lead:** Once you define your ICP in Unify, avoid selective outreach. Avoid introducing bias into how you prospect.
* **Multiple Touchpoints:** If you’ve found that a channel works best for your team, use Unify to lean into that. Unify excels at email - if that’s your preferred channel, great. If not, use email in addition to LinkedIn or phone outreach. See section 4 below to see our recommendations for email and LinkedIn outreach.
## Section 2: Actioning on Intent
There are two primary ways to act on intent data in Unify:
### Automatic Plays
* **When to use:** Both for low and high volume signals. Plays automate prospecting, qualifying, sequencing, and syncing leads to your CRM.
* **Benefits:** Reduce friction and improve intent to meeting booked conversion by immediately actioning on leads.
* Learn more about how to build Plays in [How to Create a Play](/tutorials/how-to-create-a-play).
### Manual Alerts
* **When to use:** Ideal for low volume, high value signals. It's important to ensure the sales team is accountable for acting on alerts to ensure hot leads don’t slip through the cracks.
* **Benefits:** Immediate and contextual information delivered to where your team is working.
* Most reps use Slack alerts or custom Zaps to trigger manual workflows. Learn how to set these up in our [Slack Integration Guide](/reference/integrations/slack#slack-integration-guide) and [Zapier Integration Guide](/reference/integrations/zapier).
## Section 3: Intent-Based Plays
Intent signals are indicators that there’s an opportunity to sell your product or book an intro meeting. Our customers have seen success with these intent-based Plays:
1. **Pricing Page Visits:** Checking out pricing pages indicates that prospects are seriously considering a purchase decision.
2. **[Repeat Buyers](https://www.unifygtm.com/plays/champion-tracking---outbound-to-past-customers-who-have-moved-jobs):** When someone you’ve sold to before is back on the website demonstrating high intent. This works well for businesses that have more transactional sales.
3. **[Inbound Form Submissions](https://www.unifygtm.com/plays/outbound-to-website-form-submitters):** A form submission is one of the strongest signs of intent. Convert those leads immediately by automating outreach as soon as they submit.
4. **[New Hires](https://www.unifygtm.com/plays/outbound-to-people-who-have-started-jobs-at-a-new-company):** People are more likely to purchase new tools in their first few months on a job. Targeting your ICPs that have just changed jobs can convert better.
5. **[Support Docs](https://www.unifygtm.com/plays/outbound-to-contacts-viewing-your-technical-docs):** Interest in support docs (e.g., integration details), suggests prospects are trying to understand how your product works and if it would work for them.
6. **[Social Content Engagement](https://www.unifygtm.com/plays/automate-outbound-to-linkedin-likers-commenters)**: Liking or commenting on your social posts signals that a prospect is interested in your company.
7. **[Product Tour Visits](https://www.unifygtm.com/plays/outbound-to-people-who-view-your-product-demo):** Interest in demo videos or product tours indicates a desire to understand specific product offerings in more granularity.
8. **[Retarget Paid Traffic](https://www.unifygtm.com/plays/retarget-paid-traffic):** Get more out of your spend on paid traffic by retargeting people based on UTM filters.
9. **[Closed-Lost Opportunities](https://www.unifygtm.com/plays/retarget-closed-lost-opportunities-when-they-revisit-website):** A revisit to your site by a closed-lost opportunities signals the prospect might be interested in re-engaging.
## Section 4: Section 4: Nailing Email or Linkedin Outreach
Nailing email and LinkedIn messages is key to booking the most possible meetings from Unify. A few guiding principles:
1. **Use Soft Messaging:** Use your judgement, but we typically recommend against direct mentions of website activity. Instead, tailor messages to address the pain points related to the product or service they showed interest in.
2. **Keep It Short:** Many senior leaders at your target accounts read emails on their phones, concise messages under 100 words are more likely to be read and understood. Remember that people are skimming emails.
3. **Persona-Specific Messaging:** Address specific pain points and perspectives of the different personas you sell to (e.g., sales and marketing for us). Avoid generic messages that try to cater to multiple personas, as they may resonate with none.
4. **Focus on One Product:** If you sell multiple products, pitch one per email. This approach minimizes the chances that your prospect gets confused about what you solve.
5. **Highlight Relevant Pain Points:** Rather than pitching your product, focus on speaking to a specific challenge or pain point that your prospect has. Educate the prospect on your product once you’re on the phone with them.
# Create Option
Source: https://docs.unifygtm.com/developers/api/data/attribute-options/create
POST /objects/{object_name}/attributes/{attribute_name}/options
# Delete Option
Source: https://docs.unifygtm.com/developers/api/data/attribute-options/delete
DELETE /objects/{object_name}/attributes/{attribute_name}/options/{option_name}
# Get Option
Source: https://docs.unifygtm.com/developers/api/data/attribute-options/get
GET /objects/{object_name}/attributes/{attribute_name}/options/{option_name}
# List Options
Source: https://docs.unifygtm.com/developers/api/data/attribute-options/list
GET /objects/{object_name}/attributes/{attribute_name}/options
# Update Option
Source: https://docs.unifygtm.com/developers/api/data/attribute-options/update
PUT /objects/{object_name}/attributes/{attribute_name}/options/{option_name}
# Create Attribute
Source: https://docs.unifygtm.com/developers/api/data/attributes/create
POST /objects/{object_name}/attributes
# Delete Attribute
Source: https://docs.unifygtm.com/developers/api/data/attributes/delete
DELETE /objects/{object_name}/attributes/{attribute_name}
# Get Attribute
Source: https://docs.unifygtm.com/developers/api/data/attributes/get
GET /objects/{object_name}/attributes/{attribute_name}
# List Attributes
Source: https://docs.unifygtm.com/developers/api/data/attributes/list
GET /objects/{object_name}/attributes
# Update Attribute
Source: https://docs.unifygtm.com/developers/api/data/attributes/update
PUT /objects/{object_name}/attributes/{attribute_name}
# Create Object
Source: https://docs.unifygtm.com/developers/api/data/objects/create
POST /objects
# Delete Object
Source: https://docs.unifygtm.com/developers/api/data/objects/delete
DELETE /objects/{object_name}
# Get Object
Source: https://docs.unifygtm.com/developers/api/data/objects/get
GET /objects/{object_name}
# List Objects
Source: https://docs.unifygtm.com/developers/api/data/objects/list
GET /objects
# Update Object
Source: https://docs.unifygtm.com/developers/api/data/objects/update
PUT /objects/{object_name}
# Unify Data API
Source: https://docs.unifygtm.com/developers/api/data/overview
Interact with Unify objects, attributes, and records.
# Overview
Data within Unify is stored in *objects*. Objects are the building blocks that
allow you to store and interact with data in Unify. Every object has a set of
*attributes* which represent the fields that make up the object, and *records*
represent instances of the object.
The Unify Data API allows you to interact with these objects, attributes, and
associated records. The following API groups are available:
* [Object APIs](/developers/api/data/objects/create) allow you to create and manage object definitions and schemas
* [Attribute APIs](/developers/api/data/attributes/create) allow you to create and manage the attributes on objects
* [Record APIs](/developers/api/data/records/create) allow you to create and modify object records
These APIs provide the means to connect custom data sources to Unify, import
data from external tools, and export data to other systems.
# Usage
### Request format
The base URL for all API requests to the Data API is:
```shell
https://api.unifygtm.com/data/v1
```
All APIs are built on REST principles and use standard HTTP methods to perform
CRUD operations.
### Authentication
API keys are used to authenticate requests to the Data API. You can generate an
API key in Unify by navigating to [Settings -> API Keys](https://app.unifygtm.com/dashboard/settings/integrations/api-keys).
To authenticate a request, include the following header in your request:
```http
X-Api-Key:
```
Replace `` with your Unify API key.
### Rate limits
The Data API is rate-limited to 100,000 requests per five minute window. We may
introduce daily limits in the future to prevent extraordinary usage.
# Create Record
Source: https://docs.unifygtm.com/developers/api/data/records/create
POST /objects/{object_name}/records
# Delete Record
Source: https://docs.unifygtm.com/developers/api/data/records/delete
DELETE /objects/{object_name}/records/{record_id}
# Get Record
Source: https://docs.unifygtm.com/developers/api/data/records/get
GET /objects/{object_name}/records/{record_id}
# List Records
Source: https://docs.unifygtm.com/developers/api/data/records/list
GET /objects/{object_name}/records
# Update Record
Source: https://docs.unifygtm.com/developers/api/data/records/update
PUT /objects/{object_name}/records/{record_id}
# Sync Data from Census
Source: https://docs.unifygtm.com/developers/guides/import-data/census-destination
Learn how to connect upstream data sources to Unify via Census.
# Overview
This guide assumes that you already have a Census account. If you don't, you
can sign up for a free plan [here](https://getcensus.com/), which supports up
to one billable destination.
Unify provides a Census destination which allows you to sync data from any
Census data source into Unify objects. Census supports a wide range of data
sources, including dataa warehouses, databases, and more.
# Connect Census to Unify
Within Census, navigate to **Destinations** and select **Add a destination**.
Look for the **Unify** destination type and select it.
Fill in a name for your destination and provide an API key. You can generate
an API key within Unify by navigating to [Settings -> API
Keys](https://app.unifygtm.com/dashboard/settings/integrations/api-keys).
Wait for the test to complete and then choose **Finish** to save the new
destination.
Once saved, you will see this destination listed in the **Destinations** tab.
# Sync to an object
Within Census, navigate to **Syncs** and select **Create a sync**.
Select the data source you want to sync from. This can be a table in a data
warehouse, database, or any other supported data source.
Select the Unify destination you created previously.
Choose the sync behavior. You can choose to either **Insert** or **Upsert**
records into Unify. Inserting records will only add new records, while
upserting will sync changes to existing records as well.
Choose which unique key to use for the sync. This is the key that will be
used to identify records in Unify to avoid creating duplicates and to update
existing records (if applicable).
Fill in the mapping between the fields in your data source and the
attributes on the Unify object. This is how you tell Census which fields in
your data source should be synced to which attributes in Unify.
In Unify, each object attribute has a value type which determines what kind
of data it can hold. For example, **Text** attributes can hold any string
value, while **Integer** and **Decimal** attributes can only hold numbers.
You will only be able to map fields from your data source to attributes in
Unify that support an equivalent value type.
One special value type is the **Reference** type, which is used to link to
other objects. When mapping fields in Census, you will see the unique
attributes for each object that is referenced by the object you are
syncing to.
This allows you to link records in this object to other objects based on
the data available in your data source, which is important in order to use
the data in Unify. A common example is linking rows in a data warehouse
table to company or person records in Unify so that they can be used for
pesonalization or segmentation.
Click **Run test** to send a single record from your data source to the
object in Unify.
Choose **Next** and verify the sync configuration. You can also choose to
run the sync manually, on a trigger, or on a schedule.
Once you are happy with the configuration, choose **Create** to save the
sync. You will then be able to see it in the **Syncs** tab.
# Import Data into Unify
Source: https://docs.unifygtm.com/developers/guides/import-data/overview
Learn how to sync data from external sources into Unify.
# Overview
Data within Unify is stored in *objects*. Objects are the building blocks that
allow you to store and interact with data in Unify. Every object has a set of
*attributes* which represent the fields that make up the object.
Unify provides a set of standard objects, such as companies and people, that
are used throughout the platform. In addition, you can create custom objects
that store data from external sources or represent information that doesn't fit
into the standard objects.
# Getting started
The first step is to define the objects and attributes that will store your
data. This is how you declare the format of the data and how it relates to
other objects.
Create and manage objects, attributes, and records in Unify via API.
Create and manage objects, attributes, and records within the Unify app.
Once the objects are created, you can create, update, and delete records using
the API. They will also become available in any tools that connect to Unify,
such as the Census destination for Unify.
Once the objects are created, you can sync data into Unify using the API
directly or via a supported integration.
Create, update, and link object records using the Unify API and SDKs.
Create and manage objects, attributes, and records within the Unify app.
# Intent Client Usage
Source: https://docs.unifygtm.com/developers/intent-client/client-spec
Learn how to send events using the Unify Intent Client.
The Unify Intent Client can be used to log user activity across multiple subdomains of the
same top-level domain. For example, if a user visits your marketing website at `www.yoursite.com`
and then logs into your production web application at `app.yoursite.com`, the activity in both
places will be attributed to the same person.
## Page View Events
Website page views are an indicator of buyer intent. You can log this information to the Unify platform
for usage with the `page` method.
There are two ways to collect page data with the Unify intent client:
1. Automatic monitoring of the current page
2. Manually via the client `page` method
Utilizing both of these methods when appropriate is recommended to take full advantage of intent data
within Unify.
### Automatic Page Monitoring
The Unify intent client is capable of automatically monitoring the user's current page to trigger
page events. This will happen by default when the client is installed via the [Unify Website tag](./website-tag).
If the client is installed via a package manager, you must pass the `autoPage` configuration option
when instantiating the client. See [Configuration](#configuration) below for more details.
Automatic page monitoring works in Single Page Apps, too!
In either case, this behavior can be enabled or disabled programmatically via the `startAutoPage`
and `stopAutoPage` methods on the client:
```ts
// Initialize the client and tell it to automatically monitor pages
const unify = new UnifyIntentClient(
'YOUR_PUBLIC_WRITE_KEY',
{ autoPage: true },
);
unify.mount();
// Tell the client to stop monitoring pages
unify.stopAutoPage();
// Tell the client to start monitoring pages again
unify.startAutoPage();
```
### Manual Page Logging
You can also manually trigger a page event with the `page` method on the client. This is useful
when you do not want to trigger page events for every page.
```ts
const unify = new UnifyIntentClient('YOUR_PUBLIC_WRITE_KEY');
unify.mount();
// Trigger a page event for whatever page the user is currently on
unify.page();
// Trigger a page event for a custom page other than the current page
unify.page({ pathname: '/some-custom-page' });
```
## Identify Events
All intent data collected for users by Unify is anonymous by default. When intent events are
logged, Unify will attempt to automatically de-anonymize the IP address of a user to associate
them with a specific company, but their personal identity will remain anonymous until an
identify event is triggered for them.
There are two ways to collect identity data with the Unify intent client:
1. Automatic monitoring of email input elements
2. Manually via the client `identify` method
Utilizing both of these methods when appropriate is recommended to take full advantage of intent
data within Unify.
### Automatic Input Monitoring
The Unify intent client is capable of automatically monitoring text and email input elements on
the page to collect user identity. This will happen by default when the client is installed via
the Unify JavaScript tag. If the client is installed via a package manager, you must pass the
`autoIdentify` configuration option when instantiating the client. See [Configuration](#configuration)
below for more details.
In either case, this behavior can be enabled or disabled programmatically via the `startAutoIdentify`
and `stopAutoIdentify` methods on the client:
```ts
// Initialize the client and tell it to automatically monitor inputs
const unify = new UnifyIntentClient(
'YOUR_PUBLIC_WRITE_KEY',
{ autoIdentify: true },
);
unify.mount();
// Tell the client to stop monitoring inputs for now
unify.stopAutoIdentify();
// Tell the client to start monitoring inputs again
unify.startAutoIdentify();
```
### Manual Identification
You can also manually trigger an identify event with the identify method on the client. This is
useful when users log-in with OAuth or SSO, for example, because they do not enter their email
into an input on the page.
```ts
const unify = new UnifyIntentClient('YOUR_PUBLIC_WRITE_KEY');
unify.mount();
// However you determine the currently logged-in user
const currentUser = getCurrentUser();
// Identify the current user
unify.identify(currentUser.emailAddress);
```
## Configuration
The following configuration options can be passed when initializing the client:
If installed via the [Unify Website tag](./website-tag) then the `autoPage` config will default to `true`.
Tells the client to automatically log page events whenever the current page changes.
Works for static websites and Single Page Apps. Also logs a page event for the initial page.
If installed via the [Unify Website tag](./website-tag) then the `autoIdentify` config will default to `true`.
Tells the client to automatically monitor text and email input elements on the
page for changes. When the current user enters a valid email address into an input, the client
will log an identify event for that email address.
# JavaScript Client
Source: https://docs.unifygtm.com/developers/intent-client/js-client
Install the Unify Intent client in a frontend web application framework.
## Installation
You can install the Unify Intent JS Client with your preferred package manager:
```shell npm
npm install @unifygtm/intent-client
```
```shell yarn
yarn add @unifygtm/intent-client
```
```shell pnpm
pnpm add @unifygtm/intent-client
```
## Usage
After installing the client, you must initialize it in your application code:
You should only initialize the client one time in your application.
```ts index.ts
import { UnifyIntentClient, UnifyIntentClientConfig } from '@unifygtm/intent-client';
const writeKey = 'YOUR_PUBLIC_API_KEY';
const config: UnifyIntentClientConfig = {
autoPage: true,
autoIdentify: false,
};
const unify = new UnifyIntentClient(writeKey, config);
// Do not call mount during server side rendering. Only call it in a browser context.
unify.mount();
```
You can then use the resulting client instance to log intent data. See the
[Client Spec](./client-spec) for more details on how to use the client.
## Cleanup
When you are done using the client, if you wish to clean up the side effects
generated by it, you can do so with the `unmount` method:
```ts cleanup.ts
import { UnifyIntentClient, UnifyIntentClientConfig } from '@unifygtm/intent-client';
const writeKey = 'YOUR_PUBLIC_API_KEY';
const unify = new UnifyIntentClient(writeKey);
unify.mount();
// Use the client for some time, then later...
unify.unmount();
```
# Intent Client Overview
Source: https://docs.unifygtm.com/developers/intent-client/overview
Learn how to start collecting website intent data in Unify.
Buyer intent data is at the core of what makes Unify tick. The easiest way to
start collecting this data is by installing the Unify Intent client on your
marketing website or web app.
# How it works
The Unify Intent client is a JavaScript library that allows you to collect
events from your website and send them to Unify. It supports collecting three
types of events:
e.g. a user visits the pricing page of your marketing website
e.g. a user logs into your web application with their email address
e.g. a user clicks a button to open a pricing calculator modal
When you install the Unify Intent client on your website, it can automatically
start collecting these events and sending them to Unify. You can also customize
this behavior by sending events manually using the client's API.
The Unify Intent client is fully open source and available on [GitHub](https://github.com/unifygtm/intent-js-client).
# Installation
There are several different ways to install the Unify Intent client on your
website. Choose the one that best suits your use case:
Quickly set up the Unify Intent client on a static marketing website.
Install the Unify Intent client in a React app.
Install the Unify Intent client in a different frontend web application
framework.
If you aren't sure, we recommend starting with the **Website Tag** installation
method. This is the simplest way to get started and all you need for most
marketing websites.
# Usage
If you install the client using the **React Library** or **JavaScript Client**
methods, see our [Usage Guide](/developers/intent-client/client-spec) to learn
how to use the client and start adding events.
# React
Source: https://docs.unifygtm.com/developers/intent-client/react
Install the Unify Intent client in a React app.
## Installation
You can install the Unify Intent React library with your preferred package manager:
```shell npm
npm install @unifygtm/intent-react
```
```shell yarn
yarn add @unifygtm/intent-react
```
```shell pnpm
pnpm add @unifygtm/intent-react
```
## Usage
First, wrap your React app in a `UnifyIntentProvider`:
```tsx index.tsx
import {
UnifyIntentClient,
UnifyIntentClientConfig,
UnifyIntentProvider,
} from '@unifygtm/intent-react';
const writeKey = 'YOUR_PUBLIC_API_KEY';
const config: UnifyIntentClientConfig = {
autoPage: true,
autoIdentify: false,
};
const intentClient = new UnifyIntentClient(writeKey, config);
const root = ReactDOM.createRoot(
document.getElementById('root') as HTMLElement,
);
root.render(
);
```
The `UnifyIntentProvider` automatically takes care of mounting and unmounting the client
for you whenever the component mounts and unmounts. So any components rendered in your app
can freely access and use the intent client using the `useUnifyIntent` hook:
```tsx Example.tsx
import { useUnifyIntent } from '@unifygtm/intent-react';
const Example = () => {
// Get the Unify Intent Client
const unify = useUnifyIntent();
// However you access the current user...
const currentUser = useCurrentUser();
useEffect(() => {
if (currentUser?.emailAddress) {
// Log an identify event for the current user
unify.identify(currentUser.emailAddress);
}
}, [currentUser, unify]);
...
};
export default Example;
```
You can then use the resulting client instance to log intent data. See the
[Usage](./client-spec) page for more details on how to use the client.
# Website Tag
Source: https://docs.unifygtm.com/developers/intent-client/website-tag
Quickly set up the Unify Intent client on a static marketing website.
# Installation
You can automatically load and install the client by placing a `