We build OpenSequence, an open source (Apache-2.0) engine that runs as one container and a Postgres. The steps below match how any API-first sequencer works, so most of the design carries over if you pick another one. The SDK calls and event names are the real ones from our TypeScript SDK.

Who this is for#

You have a CRM or an internal tool that reps work in every day. It might be a Next.js app on your own database, or Attio or HubSpot with your own app around them. Your reps want sequences like the ones in Outreach or Apollo. You do not want a second tool where reps re-type contacts, and you do not want to pay for a sales engagement seat per rep to get one feature.

If you have no engineer, stop here. Buy a hosted tool. Our Apollo alternatives comparison lists the hosted options with prices.

What lives where#

Your CRM owns the records reps care about: people, companies, deals, owners, and the activity timeline. OpenSequence owns five things. A contact is a copy of your person, keyed by your id. A sender is a rep, with their connected Gmail and phone. A sequence is a versioned JSON definition. An enrollment is one contact going through one sequence as one sender. A task is a call or LinkedIn step waiting for a human.

The link between the two systems is your id. You call the contact p_7 in OpenSequence because it is p_7 in your database, and every API route accepts your id wherever it accepts ours (ids and external ids). You never have to store an OpenSequence contact id.

Data flows in two directions. Your CRM pushes contacts, enrollments and task outcomes in. OpenSequence pushes events back through signed webhooks. Nothing else syncs.

Step 1. Run the engine and connect each rep's Gmail#

The install guide covers the container, the database and the project key. Two parts matter for the CRM integration.

First, register a Google OAuth client and give it to the project. If every rep is in your own Google Workspace, make the client Internal and Google skips its app review. Then create a sender per rep and send the rep through Google's consent screen from your settings page:

// lib/oseq.ts
import { OpenSequence } from '@opensequence/sdk';

export const oseq = new OpenSequence({ baseUrl: process.env.OSEQ_URL!, apiKey: process.env.OSEQ_KEY! });

// app/api/settings/connect-gmail/route.ts
import { oseq } from '@/lib/oseq';
import { requireUser } from '@/lib/auth';

export async function POST(req: Request) {
  const rep = await requireUser(req);
  await oseq.senders.upsert(rep.id, { name: rep.name, email: rep.email, timezone: rep.timezone });
  const { auth_url } = await oseq.senders.connectGoogle(rep.id, {
    return_url: 'https://crm.acme.com/settings/email',
  });
  return Response.json({ redirect: auth_url });
}

The rep's user id becomes the sender id, so later calls pass rep.id and nothing else. oseq.senders.readiness(rep.id) tells your settings page whether email is ready to send and, if not, why. The Google connection guide lists the four OAuth scopes and the redirect URI to register.

The SDK and the MCP package are not on npm yet. Install them from the repository until they are.

Step 2. Sync contacts from your CRM#

Push a person into OpenSequence when they become someone a rep might sequence. You do not need to copy your whole database. contacts.batch takes up to 500 people per call and upserts by your id:

await oseq.contacts.batch(
  people.map((p) => ({
    external_id: p.id,
    first_name: p.firstName,
    last_name: p.lastName,
    email: p.email,
    phone: p.phone,
    timezone: p.timezone,
    attrs: { company: { name: p.company.name }, deal: { stage: p.deal?.stage ?? null } },
  }))
);

Two fields deserve care. timezone decides when emails land, because the send window runs in the contact's zone and falls back to the sender's when it is empty. attrs is free JSON that templates and conditions read, so put there the fields a sequence will branch on or mention: the company name, the deal stage, the plan. When a deal moves, patch only that field with oseq.contacts.patch(p.id, { attrs: { deal: { stage: 'proposal' } } }). The attributes page shows how conditions read them.

You can also skip the sync and pass contacts inline when you enroll. The engine upserts them first. That is simpler, but a nightly batch keeps attrs fresh for people already mid-sequence.

Step 3. Define a sequence in code#

A sequence is one JSON document of nodes and named transitions. This one sends an intro email, waits up to three business days for a reply, sends a follow-up in the same Gmail thread, then creates a call task:

const definition = {
  schema_version: 1,
  entry: 'intro',
  settings: {
    send_window: { days: ['mon', 'tue', 'wed', 'thu', 'fri'], from: '08:00', to: '18:00', tz: 'contact' },
    jitter: '15m',
  },
  exit_on: ['reply', 'meeting_booked'],
  nodes: {
    intro: {
      type: 'outreach', channel: 'email', action: 'send',
      params: {
        subject: 'Quick question, {{ contact.first_name | "there" }}',
        body: 'Hi {{ contact.first_name | "there" }}, I saw {{ attrs.company.name | "your team" }} is hiring. Worth a call?\n\n{{ sender.first_name }}\n\n{{ unsubscribe_url }}',
      },
      next: { sent: 'wait_reply', skipped: 'wait_reply' },
    },
    wait_reply: {
      type: 'wait_for',
      params: { events: ['reply:email'], timeout: '3bd' },
      next: { 'reply:email': 'done', timeout: 'follow_up' },
    },
    follow_up: {
      type: 'outreach', channel: 'email', action: 'send',
      params: { subject: 'Re: Quick question', body: 'Bumping this up, {{ contact.first_name | "there" }}.\n\n{{ unsubscribe_url }}', reply_in_thread: true },
      next: { sent: 'call' },
    },
    call: {
      type: 'task',
      params: { kind: 'call', title: 'Call {{ contact.first_name | "them" }}', due: '1bd', expire: '3bd' },
      next: { completed: 'done', no_answer: 'done' },
    },
    done: { type: 'end', params: { label: 'Done' } },
  },
};

const { ok, problems } = await oseq.sequences.validate(definition);
const { sequence, version } = await oseq.sequences.create({ name: 'Inbound demo follow-up', definition });
await oseq.sequences.versions.publish(sequence.id, version.id);

A template that reads contact.first_name without a fallback fails to publish, because some contacts have no first name. A body without {{ unsubscribe_url }} publishes with a warning. A published version cannot change, so contacts already in it finish the version they started; edits go into a new version (versions).

Keep the definitions in your repository next to the code that enrolls into them. A pull request then shows what a sequence change does, and a deploy script can create the new version and publish it.

Step 4. Put an Enroll button in your CRM#

The button calls one route on your server. The route checks the user, then enrolls the selected people as that rep:

// app/api/sequences/[id]/enroll/route.ts
import { OpenSequenceError } from '@opensequence/sdk';
import { oseq } from '@/lib/oseq';
import { requireUser } from '@/lib/auth';

export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
  const rep = await requireUser(req);
  const { id } = await params;
  const { personIds, rehearse } = (await req.json()) as { personIds: string[]; rehearse?: boolean };

  try {
    const result = await oseq.sequences.enroll(id, {
      contacts: personIds,
      sender: rep.id,
      enrolled_by: rep.id,
      enrolled_by_kind: 'user',
      mode: rehearse ? 'dry_run' : 'live',
    });
    return Response.json({ accepted: result.accepted, skipped: result.skipped, capacity: result.capacity });
  } catch (err) {
    if (err instanceof OpenSequenceError && err.is('ALREADY_IN_SEQUENCE')) {
      return Response.json({ conflicts: (err.details as { conflicts: unknown[] }).conflicts }, { status: 409 });
    }
    throw err;
  }
}

Three behaviours of the enroll call shape the UI. A contact can be in one active sequence at a time. If any selected person already is, the call enrolls nobody and returns a 409 that names each conflict, so the dialog can say "Dana Whitfield is already in UK facilities managers" and let the rep remove her. Suppressed people come back in skipped with a reason, and the rest still enroll. capacity tells you how many days the first emails take at the rep's daily cap, which the dialog can show as "first emails finish in about 3 days".

Call oseq.sequences.previewEnrollment with the same arguments before the rep confirms. It returns the same result and errors and writes nothing. mode: 'dry_run' goes one step further: it creates real enrollments whose emails are rendered and recorded but not sent, which is how you rehearse a new sequence on one contact (enrolling).

Step 5. Write activity back to your CRM#

Register one webhook endpoint and handle the events your timeline needs. The handler verifies the signature on the raw body, then writes rows keyed by the event id so a retried delivery does nothing twice:

// app/api/hooks/opensequence/route.ts
import { verifyWebhook } from '@opensequence/sdk';
import { db } from '@/lib/db';

type Signal = { kind: string; channel: string | null; occurred_at: string };
type Contact = { external_id: string };

export async function POST(req: Request) {
  const event = verifyWebhook({ secret: process.env.OSEQ_WEBHOOK_SECRET!, headers: req.headers, body: await req.text() });
  const data = event.data as Record<string, unknown>;

  switch (event.type) {
    case 'signal.received': {
      const { signal, contact } = data as { signal: Signal; contact: Contact };
      await db.activity.upsert({
        id: event.id,
        personId: contact.external_id,
        kind: signal.kind,
        channel: signal.channel,
        at: signal.occurred_at,
      });
      break;
    }
    case 'enrollment.exited': {
      const { enrollment, exit_reason } = data as { enrollment: { contact: string }; exit_reason: string };
      const person = await oseq.contacts.get(enrollment.contact);
      await db.person.update({ id: person.externalId, sequenceStatus: `exited: ${exit_reason}` });
      break;
    }
  }
  return new Response(null, { status: 204 });
}

signal.received covers replies, bounces, opt-outs, meetings, connected calls and completed tasks, and it carries your id for the contact. run.done fires for every sent step if you want each email on the timeline too. enrollment.exited and enrollment.completed tell you a person left a sequence and why. Deliveries retry for three days and arrive in order per enrollment, but they can arrive twice, which is why the handler upserts by event.id (receiving webhooks).

Create the endpoint once with oseq.webhooks.create({ url, event_types: ['signal.received', 'enrollment.exited', 'task.created', 'task.expired'] }) and store the secret it returns. The call needs an admin-scoped key.

Step 6. Give each rep a task inbox#

Call and LinkedIn steps become tasks for the rep. OpenSequence does not send LinkedIn messages itself, because automating LinkedIn breaks its user agreement, so a person does those steps. Your CRM shows the open tasks and posts the outcome back:

const { items } = await oseq.tasks.list({ sender: rep.id, status: 'open' });

// when the rep logs the call
await oseq.tasks.complete(taskId, { outcome: 'connected', note: 'Booked a demo for Thursday.' });

The outcome is free text up to 32 characters. The sequence can branch on it, and an outcome listed in the node's connected_outcomes counts as a conversation, which exits the enrollment when exit_on includes reply. A task nobody completes expires and the sequence takes its no_answer path. To keep the inbox live without polling, mirror task.created and task.expired into your own table. The tasks page lists the fields to store.

Step 7. Stop sequences from CRM events#

OpenSequence sees replies in threads it started, bounces, unsubscribe clicks, STOP texts and meetings in a connected Google Calendar. It does not see your CRM. When something there should end the outreach, report it:

// a rep marked the person do-not-contact
await oseq.contacts.reportEvent(person.id, { id: `dnc-${person.id}`, type: 'suppressed', reason: 'do_not_contact' });

// a meeting was booked through a tool OpenSequence does not watch
await oseq.contacts.reportEvent(person.id, { id: calendarEventId, type: 'meeting_booked', occurred_at: new Date(start) });

// the deal closed, so take the person out of whatever sequence they are in
await oseq.enrollments.exitMany({ contact: person.id, label: 'Deal won' });

Reported events are idempotent by the id you give them, so a sync job that runs every night can resend the whole do-not-contact list safely with oseq.contacts.reportEvents. Treat the suppression report as mandatory. If your CRM knows someone asked not to be contacted and the engine does not, it will keep emailing them (contact events). exitMany needs an admin key, so call it from a background job, not from the browser path.

Step 8. Let an agent use the same setup#

The MCP server in the repository exposes the same API to Claude, Cursor or any MCP client, scoped by the key you give it. An agent can list sequences, validate a definition, preview and enroll contacts, read a contact's journey, work tasks and read analytics. It cannot create or publish a sequence, and the one-active-sequence rule applies to agents too, so a duplicate enrollment fails the same way it does for a rep. The server marks every enrollment it makes with enrolled_by_kind: 'agent', so your audit trail shows which ones an agent made.

What you still build yourself#

OpenSequence has no user interface. The engine and the calls above are the easy part. The screens are yours:

That is about 56 hours for an engineer who knows your CRM, plus the install. The numbers are our estimate, not a measurement, and the enroll dialog and the task inbox are the two most likely to run over. Our Outreach vs Salesloft cost breakdown puts those hours next to per-seat prices for a 15-rep team.

Buying is the better choice when reps need a sequence editor and dashboards on day one, when your team sends from Microsoft 365, since OpenSequence sends through Gmail only today, or when nobody owns the CRM codebase. Building the engine itself is a different and much larger job. Our guide to what breaks when you build your own sequencer covers it. If you are moving off a tool you already use, the migration guide covers running both while contacts finish their old sequences.

FAQ#

Can I add email sequences to a custom CRM without building the engine?#

Yes. Run a sequencing engine with an API next to your CRM, push contacts and enrollments to it, and receive webhooks back. OpenSequence is one open source option. It sends from each rep's Gmail and handles timing, caps, threading and reply detection, so your code only needs the screens and the sync.

Does the CRM need to store sequence data?#

Only what you show. Contacts are keyed by your own id, so you never store an OpenSequence contact id. Most teams keep a sequence status on the person and an activity row per webhook event, and read anything else, such as a full journey, from the API when a rep opens it.

How do I stop a sequence when a deal changes stage?#

Either call exitMany with the contact from the code that changes the stage, or patch the stage into the contact's attrs and let a condition node in the sequence branch on it. The first stops the sequence at once. The second lets the sequence decide, for example by skipping the call task for deals already in proposal.

Can I use this with Attio or HubSpot instead of my own CRM?#

Yes, as long as you have an app or a job that calls the API. The steps are the same: sync people, enroll from your app, write events back. OpenSequence also reads Attio directly. Conditions can branch on the person, company and open deal in Attio at the moment they run (connect Attio).

Will emails come from the rep's own address?#

Yes. Each email goes out through the rep's connected Gmail account with the Gmail API, so it sits in their Sent folder and replies land in their inbox. Follow-ups with reply_in_thread stay in the same Gmail thread.

We build OpenSequence, so read this page with that in mind. We list it first, cover every other tool with the same sections, and end with the cases where you should stay on Apollo. All prices come from public pricing pages as of October 2026, except Outreach and Salesloft, which do not publish prices.

Why teams look past Apollo for sequencing#

Plenty of teams like Apollo. Its own pricing page cites 4.7 out of 5 across 9,690 reviews. Problems start when a team runs all of its outbound through a tool that charges for data.

Credits pay for everything. One credit buys an email address, eight buy a phone number, and the US dialer costs one credit per 30 seconds. Credits also pay for warmup, purchased domains and mailboxes, and AI research. Apollo pools them across the team, grants them at the start of the billing cycle, and resets them with no rollover. A rep who dials or warms up a mailbox draws from the same pool as the person building lists.

The cheaper plans limit sending. Basic costs $49 per seat per month, billed annually, and allows 1 mailbox per user and 250 emails per day. Multiple mailboxes and unlimited daily sends start at Professional, $79 per seat per month. The free plan caps you at 2 sequences per team.

Many deliverability problems come from defaults. Apollo sends through the mailbox you link, so the sending reputation belongs to your domain. The shared part is the default tracking domain for opens and clicks. Apollo's help center says a custom tracking subdomain protects your primary domain's reputation. If your Apollo emails land in spam, check that setting and your SPF, DKIM and DMARC records before you blame the tool. Changing sequencers will not fix a bad list. Our guide to cold email deliverability on your own infrastructure covers the checks.

Data and contract complaints are common. On Trustpilot, Apollo scores 3.1 out of 5 from 1,365 reviews, and 36% are one star. Recent reviews repeat the same complaints. Credits expire each cycle, annual plans cannot shrink mid-term, and reviewers say they cross-check the contact data against other sources.

Apollo does two jobs#

Apollo sells a contact database and a sequencer in one seat. The two jobs have different users inside your team. Someone in RevOps or an SDR lead builds lists and spends credits. Every rep sends sequences.

That split matters for cost. Ten reps on Professional, at $79 per seat per month, cost $9,480 a year. If only two people build lists, two Basic seats cost $1,176 a year and still come with 60,000 pooled credits. The other eight reps then need a sequencer, and that is the decision this page is about.

Whatever you pick, the handoff is a contact record. Your data tool exports the contact or returns it from an API, and your sequencer accepts the contact and enrolls it. In OpenSequence that is two requests:

curl -X PUT $SEQ/v1/contacts/p_7 -H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
  -d '{"first_name":"Dana","email":"dana@example.com","timezone":"Europe/London","attrs":{"source":"apollo"}}'
curl -X POST $SEQ/v1/sequences/$SEQ_ID/enrollments -H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
  -d '{"contacts":["p_7"],"sender":"u_42"}'

The alternatives#

OpenSequence (ours)#

OpenSequence is an open source sequencing engine, licensed Apache-2.0, that you run yourself. It ships as one Docker image and runs on a Postgres database you own. You define sequences as versioned JSON through a REST API, a TypeScript SDK or an MCP server, and you enroll contacts as a given rep. OpenSequence sends you a signed webhook when someone replies, books a meeting, bounces or opts out. Email goes out from each rep's own Gmail account, and follow-ups can reply in the same thread. Texts and calls go through Allo. LinkedIn steps become tasks for a person. The how it works page follows one contact from enrollment to exit.

It fits a team with an engineer and a CRM or internal tool where reps already work. There is no per-seat price. You pay for the container and the database.

It differs from Apollo in what it leaves out. It has no contact database, no warmup and no user interface, so your CRM or an internal tool is the UI. Email works only through Google Workspace today. SMTP and IMAP adapters are on the roadmap under "later", so a Microsoft 365 team cannot use it yet. It is pre-1.0, and the SDK and MCP packages are not on npm yet. We are still verifying the Allo and Attio adapters against real accounts. Each sender gets a default cap of 30 emails per day and 60 seconds between sends, and you can change both per channel (senders and limits).

Outreach or Salesloft#

These are the enterprise sales engagement suites. They bundle sequences, a dialer, call recording, forecasting and deal management, with a two-way Salesforce sync. They fit teams of 30 reps and up with a RevOps owner and a Salesforce instance.

Neither vendor publishes prices. Vendr puts the median Outreach contract at $45,600 a year, based on 919 purchases. For Salesloft, Vendr's median is $30,740 a year and its range for teams of 10 to 25 users is $60 to $100 per user per month. Both figures are third-party estimates from February 2026.

Compared with Apollo, both add a dialer, call recording, forecasting and deal management, and do nothing for list building. Expect a separate data provider, an annual contract and a sales process to buy them. Our Outreach vs Salesloft cost breakdown goes into the line items.

HubSpot Sequences#

Sequences are a feature of HubSpot Sales Hub, available from the Professional plan. They fit teams whose CRM is already HubSpot and who want enrollments, tasks and replies on the same contact record.

Sales Hub Professional is $90 per seat per month billed annually, plus a required one-time onboarding fee of $1,500 (HubSpot pricing). It allows 500 sequence emails per user per day. Enterprise is $150 per seat, with a $3,500 onboarding fee and 1,000 emails per user per day.

Compared with Apollo, there is no sync to set up, because the sequences run inside the CRM. HubSpot does not sell a contact database comparable to Apollo's, and LinkedIn steps need a Sales Navigator subscription.

lemlist#

lemlist is a cold outreach tool that sends email. Its Multichannel plan adds LinkedIn, SMS, calls and a WhatsApp add-on. It fits small teams and founders who run cold campaigns from a few mailboxes.

The Email plan is $55 a month billed yearly for unlimited users and up to 50,000 emails a month. Multichannel starts at $87 a month billed yearly and includes 5 senders per user (lemlist pricing). Contact data is an add-on. On yearly billing, $16 a month buys 2,000 credits, which is 400 emails or 100 phone numbers.

Compared with Apollo, lemlist's pricing does not tie sending to data credits. You can buy data from lemlist, from Apollo, or from neither. We wrote a longer piece on a self-hosted lemlist alternative.

Instantly#

Instantly is a high-volume cold email platform that sends from many mailboxes, rotates across them and warms them up. It fits agencies and outbound teams that send from dozens of secondary domains.

Growth is $47 a month, or $37.60 a month on yearly billing, for 5,000 emails and 1,000 uploaded contacts a month. Hypergrowth is $97 a month, or $77.60 yearly, for 125,000 emails and 25,000 contacts (Instantly pricing). Both list unlimited email accounts, and the price is per plan, not per seat.

Compared with Apollo, Instantly focuses on sending volume across many inboxes, and its sequences are email only.

Reply.io#

Reply.io is a multichannel sequencer with email, LinkedIn, calls, SMS and semi-automated WhatsApp. It fits teams that want one tool for everything, as with Apollo, but with more channels and no credit pool tied to sending.

Email Volume starts at $49 per user per month billed annually, with 1,000 active contacts a month and unlimited mailboxes under a fair use policy. Multichannel starts at $89 per user per month billed annually with 10 mailboxes and unlimited active contacts (Reply.io pricing). Both include 50 data credits a month.

Compared with Apollo, Reply.io charges for active contacts and channels instead of data credits. LinkedIn automation on the Email Volume plan costs $69 per account per month extra.

Comparison matrix#

Prices are for the lowest plan that includes sequences, billed annually, as of October 2026.

How to choose#

Three questions decide most cases: how many reps send, what you can spend per rep, and whether someone on the team can run a service.

The engineer question decides whether OpenSequence is on the list at all. Someone has to run Postgres and a container, register a Google OAuth client, and build or connect the screens reps use. The install guide lists every step. If nobody on the team wants that job, pick a hosted tool. If you are considering building your own, our guide to building your own sales sequencer lists the parts that take longer than expected. The migration guide covers moving live sequences without double-sending.

When to stay on Apollo#

Stay if your reps prospect and send in the same session. Searching, enriching and enrolling from one screen is Apollo's strongest feature. Split across two tools, that flow needs an export or a sync between search and send.

Stay if you have fewer than about ten reps and use most of your credits. At $79 per seat you get data, a dialer, warmup and sequencing on one bill. A separate data tool plus a separate sequencer often costs more.

Stay if your team is on Microsoft 365 and you were considering OpenSequence, since it sends only through Gmail today.

Stay if your problem is deliverability and you have not set a custom tracking subdomain, authenticated your domains and cleaned your lists. Those fixes are free and apply to every tool on this page.

FAQ#

What is the best free alternative to Apollo.io for sequences?#

HubSpot's free tier does not include sequences, and lemlist, Instantly and Reply.io charge after a trial. OpenSequence has no license fee because it is open source and self-hosted, so you pay only for the server and database. It needs an engineer to run and has no contact data.

Is there an open source Apollo alternative?#

For the sequencing half, yes. OpenSequence is an Apache-2.0 engine that runs email, SMS, call and LinkedIn task sequences on your own infrastructure. We do not know of an open source tool that replaces Apollo's contact database, since that data is the product.

Can I keep Apollo for data and use another tool for sequences?#

Yes, and it is often the cheapest setup. Keep Basic seats for whoever builds lists, since Apollo pools credits across the team. Export contacts, or call Apollo's API from your CRM. The sequencer then receives the contact and enrolls it.

Why do my Apollo emails go to spam?#

The usual causes are the default shared tracking domain, missing SPF, DKIM or DMARC records, new domains sending too much too soon, and stale lists that bounce. Apollo recommends a custom tracking subdomain for every sending domain. Fix those before you switch tools, because the same mailbox and list will behave the same in any sequencer.

How much does Apollo cost per user in 2026?#

As of October 2026, Apollo charges $49 (Basic), $79 (Professional) and $119 (Organization, minimum 3 seats) per seat per month on annual billing. Monthly billing costs more, since annual billing saves 24%. Each plan includes a yearly credit allowance per seat: 30,000, 48,000 and 72,000.

Each section below names a failure mode, then shows how OpenSequence handles it, with code from the repo.

The naive version#

// every 5 minutes
for (const e of await db.enrollments.due()) {
  await gmail.send(render(e.step, e.contact));
  await db.enrollments.advance(e.id);
}

What goes wrong with it in the first month:

Scheduling in the recipient's time zone#

First you need the zone. OpenSequence takes the contact's IANA zone if your app sent one. Failing that, it derives a zone from the phone number, using a NANP area code or a country with one zone. After that it tries a single-zone country and, for email only, the sender's zone. For SMS it does not guess. It skips the step with no_timezone, because the 8:00 to 21:00 calling window in 47 CFR 64.1200(c)(1) applies in the recipient's local time.

The second problem is daylight saving time. In 2026 Europe falls back on October 25 and the US on November 1, so for one week London is four hours ahead of New York instead of five. A send time stored as "14:00 UTC" goes out at the wrong local hour that week. OpenSequence computes send windows in the contact's zone with @date-fns/tz. In its duration grammar 2d is 48 hours, while 2bd moves forward two weekdays in the contact's zone and keeps the wall-clock time. One test covers a step due Saturday at 10:00 BST with a weekday window of 08:00 to 18:00. The step sends on Monday at 08:00 GMT, after the clock change.

OpenSequence computes the timing when an enrollment enters a step and checks it again when the step runs, because the window and the caps can change in between. A configurable jitter keeps 300 sends from going out at exactly 09:00.

Never double-send under at-least-once delivery#

Queues deliver at least once. Say a worker crashes after Gmail accepted the email but before your database recorded it. The worker retries, and the prospect gets two copies. OpenSequence prevents this with two layers.

The first layer is ownership. While an executor works on a step, the enrollment's owner_run_id points at that run and next_run_at is null, so the planner cannot see it. Only the executor that finishes the run releases the enrollment. There is no lease that could expire in the middle of a send.

The second layer is an idempotency key on the email itself. Each run has a unique key (seq:<enrollment>:<node>:a<attempt>). OpenSequence derives the Message-ID header from that key, and a retry asks Gmail whether the message already went out:

export function messageIdFor(env: StepEnv, domain: string): string {
  return `<${env.run.idempotencyKey.replace(/[^a-z0-9]/gi, '.')}@${domain}>`;
}

const already = attempt > 1 ? await deps.providers.email.findSent({ channel: channelRef, messageId }) : null;
const sent = already ?? (await deps.providers.email.send({ /* ... */ messageId, headers }));

findSent is a Gmail search for rfc822msgid:<id>. Texts have no equivalent key. For an SMS with an unknown outcome, OpenSequence searches the last ten minutes of outbound texts to that number. If that search is inconclusive, the run moves to needs_review instead of retrying. A double text is worse than a late one.

The database also rejects a second active enrollment for the same contact:

CREATE UNIQUE INDEX enrollments_one_active_idx ON seq.enrollments (project_id, contact_id)
  WHERE status IN ('active', 'paused', 'waiting_limit');

With the default Postgres queue, the enqueue is an insert in the same transaction as the run record, so "run recorded" and "message queued" commit together. The queues page covers the Redis case, where a reaper re-enqueues any run that was recorded but never queued.

Per-mailbox caps#

Providers publish ceilings. Google Workspace allows 2,000 messages a day per user (500 on trial accounts). Exchange Online allows 10,000 recipients a day and 30 messages a minute per mailbox. The Gmail API charges 100 quota units per messages.send against a budget of 6,000 units per user per minute. Your reply polling draws on the same budget.

Those numbers are ceilings, not targets. A provider can flag a rep's inbox that sends cold email anywhere near them. OpenSequence defaults each email channel to 30 sends per rolling 24 hours with a 60-second minimum gap. You can configure both per sender. When a sender is over the cap, OpenSequence defers the step instead of skipping it, and the enrollment shows waiting_limit. On each tick the planner claims at most 50 due enrollments per sender with FOR UPDATE SKIP LOCKED, and it takes follow-ups before first touches. One rep's 5,000-contact import therefore cannot starve everyone else.

OpenSequence sends through Gmail only today. It does not support Outlook or Microsoft 365 mailboxes. An SMTP and IMAP adapter is on the roadmap.

Reply detection and threading#

Gmail's threading rules need three things: the threadId on the send request, In-Reply-To and References headers as RFC 5322 defines them, and a matching subject. A reply_in_thread follow-up in OpenSequence sets the first two, and keeping the subject consistent is up to you. In-Reply-To names the enrollment's last email, and References lists every email of the thread so far. OpenSequence takes the Gmail threadId from the thread where it recorded the earlier send.

For inbound mail, the service reads the Gmail history feed from a stored cursor every minute. It keeps only messages in threads it started in the last 30 days. It matches them by thread id, or by finding our Message-ID in the In-Reply-To and References headers (RFC 5322 section 3.6.4). The service stores nothing else from the rep's mailbox, and it stores inbound bodies only if the project turns that on.

An out-of-office reply arrives in the thread and looks like a real reply. OpenSequence treats a message as automatic when it has Auto-Submitted set to anything but no (RFC 3834), an X-Autoreply or X-Autorespond header, Precedence: auto_reply, or a subject like "Automatic reply" or "Out of office" (with German, French and Spanish variants). An auto-reply never removes the contact from the sequence. Instead, OpenSequence pauses the enrollment until the return date it parses from the subject or snippet. If it finds no date, the pause lasts 7 days.

Bounces and suppressions#

A bounce is an email from mailer-daemon@ or postmaster@ with a message/delivery-status part (RFC 3464). The adapter reads the status code and finds the original by our Message-ID in the attached headers. A 5.x.x status is permanent and a 4.x.x is transient (RFC 3463). On a permanent bounce, OpenSequence writes a hard_bounce suppression and exits the contact. A transient bounce writes no suppression.

OpenSequence checks suppressions at enrollment and again at send time, because a contact can opt out in between. The consent and suppressions page lists every source.

One-click unsubscribe (RFC 8058)#

Google requires one-click unsubscribe from senders of more than 5,000 messages a day to Gmail accounts. It asks senders to honor requests within 48 hours and says to never reach a 0.3% spam rate. Yahoo asks for the same header and asks senders to honor opt-outs within 2 days. Most reps sending 1:1 stay under the threshold. The header still costs little, and it gives a recipient a way out other than a spam complaint.

RFC 8058 sets four requirements. The List-Unsubscribe header must carry an HTTPS URI. List-Unsubscribe-Post must be exactly List-Unsubscribe=One-Click. The POST must work with no cookies and no redirect. The DKIM signature must cover both headers. OpenSequence adds both headers to every email:

const headers = { 'List-Unsubscribe': `<${unsubscribe}>`, 'List-Unsubscribe-Post': 'List-Unsubscribe=One-Click' };

The problem is link scanners. Many corporate mail filters fetch the URLs in a message, so a GET that unsubscribes removes people who never clicked. OpenSequence's GET /u/{token} only renders a page with a button. Only a POST writes the suppression and exits the enrollment, whether it comes from the button or from the mail client's one-click action. OpenSequence signs the token with HMAC, and the token is valid for 90 days. Once you set up a DKIM key for your Workspace domain, Gmail signs with it. Check that the h= tag in a sent message's DKIM-Signature lists both headers.

Stopping on a meeting or a CRM change#

A sequencer only sees its own channels. OpenSequence detects a meeting when a new event on the sender's connected Google Calendar has the contact as an attendee. It cannot see a booking in another tool, a deal moved to "closed won" or a do-not-contact flag in your CRM. Your app reports those through the contact events API, which is idempotent on your event id. A homegrown sequencer has the same problem, so budget the CRM webhooks either way. The CRM integration tutorial shows that code for OpenSequence. OpenSequence does not watch the CRM. A condition step can still read a live value from Attio, such as crm.deal.stage, when it decides a branch.

A reply can also arrive in the second between the last check and the provider call. The enrollment row lock and a last-moment status check catch almost all of these. No design can close the remaining race, so OpenSequence logs those cases instead of hiding them.

Editing a live sequence#

Someone deletes step 3 while 200 people wait on it. OpenSequence makes published versions immutable, with a trigger that raises an error on any update to a non-draft definition. Each enrollment stays on the version id it started with, and new enrollments use the new default. To move people, you exit and re-enroll them. Drafts use an optimistic lock, so two editors cannot overwrite each other. The versions page has the details.

Call tasks#

A task node creates a task for the rep and waits. It branches on the outcome your app sends back (connected, voicemail). If the task expires, the node takes the no_answer branch, and by default a task expires 7 days after it is due. With dialer: true, the number goes into the rep's Allo dialer and the call result completes the task. Otherwise your app needs a task inbox.

Observability#

Six weeks from now, someone will ask why Dana got that email, and you need an answer. OpenSequence writes every node execution as a row in an append-only run ledger. The row records the facts a condition read and the branch it took. Logs are Pino JSON with the enrollment and run ids on every line. The health endpoints return queue depths and the last run of each scheduler job. The observability page lists what is missing today: a Prometheus endpoint and a per-channel circuit breaker.

How long a build takes#

This is our estimate for one senior engineer who has built queue-backed systems before, with Gmail as the only mailbox provider.

Most of the range comes from the inbound side, where you keep finding bounce and auto-reply formats your parser does not handle. Each extra mailbox provider adds weeks. If your Google OAuth client is public rather than internal to your Workspace, Google reviews apps that request restricted Gmail scopes. You do not control how long that review takes. After launch, someone has to handle token failures, provider API changes and the occasional stuck enrollment.

When building your own is the right call#

Build it when sequencing is your product, or when your volume is tiny. A founder sending 20 emails a day from one inbox can get by with a script and a spreadsheet. Also build it when your rules fall far outside what any tool models and an engineer will own the code for years.

Buy a SaaS tool when nobody on the team can own a service, when reps need a finished UI tomorrow, or when you need Outlook mailboxes, open tracking or A/B tests on content. OpenSequence has none of those last three today. The migration guide covers moving off a SaaS tool, and the Outreach vs Salesloft cost breakdown prices the buy side.

Self-host an open source engine when you want to own the data and drop per-seat pricing without spending the 20 weeks. OpenSequence is headless, so you bring the UI. It runs as one container on a Postgres database you own. How it works is the 10-minute version of this post, and the self-hosted deliverability guide covers DNS and warm-up.

FAQ#

How long does it take to build a sales sequencer?#

A script that sends a follow-up after N days takes a few days. A production sequencer with time zones, idempotent sends, reply and bounce detection, one-click unsubscribe and versioning is a bigger job. We estimate about 16 to 24 engineer-weeks for one mailbox provider.

Can I use a cron job to send follow-up emails?#

For one inbox and a few dozen emails a day, yes. It breaks once you run two workers, retry after a crash, or need to stop the moment someone replies. At that point you need row-level ownership of each step and an idempotency key on each send.

Do cold emails need RFC 8058 one-click unsubscribe?#

Google's and Yahoo's rules require it for bulk senders, which Google defines as senders of more than 5,000 messages a day to Gmail accounts. Most 1:1 sales email falls under that line. Adding the List-Unsubscribe and List-Unsubscribe-Post headers costs little and turns a likely spam complaint into an unsubscribe.

How do I tell an out-of-office reply from a real reply?#

Check the Auto-Submitted header from RFC 3834 first, then X-Autoreply, X-Autorespond and Precedence: auto_reply, then the subject line. Some auto-replies set none of these headers, so the subject check is not optional. Pause the sequence on an out-of-office instead of exiting it.

How many emails can a Google Workspace user send per day?#

Google's published limit is 2,000 messages a day per user, or 500 on trial accounts. For cold outreach from a rep's own inbox, stay far below that. OpenSequence defaults to 30 a day per sender.

Does OpenSequence work with Outlook or Microsoft 365?#

Not today. OpenSequence sends email through Gmail with each rep's Google account, and an SMTP and IMAP adapter is on the roadmap.

We build OpenSequence, an open source sequencing engine you run yourself, so read this with that in mind. Near the end, one table splits each item into what the engine does and what you configure. The last table lists the checks to run before the first send.

What you take on when you leave the vendor#

OpenSequence sends each email through the rep's own Google Workspace mailbox with the Gmail API. Google's servers relay the message, so reverse DNS, TLS and IP reputation are Google's problem, not yours. You own the domain, its DNS records, the list, the volume, the content and the monitoring.

Today the only email provider is Google. Reps on Microsoft 365 cannot send through OpenSequence yet. SMTP and IMAP are on the roadmap as a later phase, with no date. The engine also has no warm-up, no email verification and no inbox placement testing. If you want those bundled, and nobody on the team will manage DNS and check bounce numbers every week, a hosted cold email tool is the better choice. Our lemlist alternative post covers that tradeoff.

Which rules are law and which are provider policy#

The FTC states that CAN-SPAM "makes no exception for business-to-business email", and its guide puts the penalty at up to $53,088 per violating email. PECR lets you email companies without consent, but sole traders and some partnerships count as individuals and need consent. EU rules differ by country. Get local advice before you email into the EU.

Gmail, Yahoo and Outlook sender requirements#

Google's rules took effect on February 1, 2024. Every sender to personal Gmail needs SPF or DKIM, valid forward and reverse DNS, TLS, RFC 5322 formatting, and a spam rate below 0.3%. Google defines a bulk sender as one that sends close to 5,000 messages a day to personal Gmail accounts. Bulk senders also need SPF and DKIM together, a DMARC record, From alignment with SPF or DKIM, and one-click unsubscribe on marketing mail. Google's FAQ adds three details that matter for cold outreach. Messages from the same primary domain, subdomains included, count toward the 5,000. Once a domain reaches bulk status, it never loses it. And starting November 2025, "Gmail is ramping up its enforcement on non-compliant traffic", with temporary and permanent rejections and a faster timeline for new domains.

Yahoo's list matches Google's and asks bulk senders to honor unsubscribes within 2 days. Yahoo gives no volume number for "bulk". Microsoft's rules for Outlook.com, Hotmail and Live addresses started May 5, 2025, for domains sending over 5,000 a day. Microsoft first planned to route failing mail to Junk. An April 29 update to its announcement switched to rejection, with the error 550; 5.7.515 Access denied, sending domain [SendingDomain] does not meet the required authentication level.

Two exceptions matter for B2B. Google's FAQ says the guidelines "don't apply to messages sent to Google Workspace accounts". Microsoft's rules cover the consumer service only, not Microsoft 365. Most B2B prospects use exactly those business mailboxes. Meet the published rules anyway. Your lists contain personal Gmail and Outlook addresses, and business inboxes still filter spam. These are also the only numbers any provider publishes.

The 0.3% spam rate and Postmaster Tools#

Google asks senders to keep the spam rate in Postmaster Tools below 0.1% and to never reach 0.3%. A bulk sender above 0.3% loses access to Google's mitigation until the rate stays under 0.3% for 7 consecutive days.

Postmaster Tools has two limits for a sales team. Its data "only applies to messages sent to personal Gmail accounts", and "data might be missing if the total number of messages for a given day is too low" (Postmaster Tools help). Five reps at 30 emails a day, mostly to Workspace addresses, will often see empty charts. Register the domain anyway. Day to day, watch the numbers you do control: bounces per step, opt-outs, and replies that say "stop emailing me".

SPF, DKIM and DMARC for a secondary sending domain#

Send cold email from a separate registered domain, not your main one and not a subdomain of it. Google counts subdomains toward the primary domain, so mail.acme.com counts as acme.com for bulk sender status. If getacme.com gets blocked, invoices and support replies from acme.com still arrive. The cost is one extra Workspace user per sending mailbox, plus a domain that recipients do not recognize. A Workspace user costs $7 per month on Business Starter with an annual plan as of October 2026 (pricing). Redirect the new domain's website to your main site, so a prospect who types it in reaches your real site.

Add getacme.com to Workspace, create the reps' sending mailboxes on it, and publish these records:

; SPF: only Google may send for getacme.com
getacme.com.                      TXT  "v=spf1 include:_spf.google.com ~all"

; DKIM: generate a 2048-bit key in Admin console > Apps > Google Workspace > Gmail > Authenticate email
google._domainkey.getacme.com.    TXT  "v=DKIM1; k=rsa; p=MIIBIjANBgkqh...IDAQAB"

; DMARC: monitor first, aggregate reports go to the main domain
_dmarc.getacme.com.               TXT  "v=DMARC1; p=none; rua=mailto:dmarc@acme.com; adkim=r; aspf=r"

; on acme.com: lets getacme.com send its DMARC reports there (RFC 7489, section 7.1)
getacme.com._report._dmarc.acme.com.  TXT  "v=DMARC1"

The SPF record follows Google's SPF guide. Publish exactly one SPF record per domain and stay under the 10 DNS lookup limit in RFC 7208. The DKIM selector google and the 2048-bit key come from Google's DKIM guide. After DNS propagates, click "Start authentication" in the Admin console. The external report record on acme.com is the easy one to miss. Without it, receivers do not send the aggregate reports to the acme.com address.

p=none meets the Google, Yahoo and Microsoft minimum. Microsoft recommends p=reject. Once a few weeks of reports show only Google as a source, move to p=quarantine.

Alignment#

DMARC passes when the From domain matches the domain SPF checked or the d= domain of a valid DKIM signature. Relaxed mode (adkim=r, aspf=r) accepts a match on the organizational domain. Send a test from a rep's mailbox to a personal Gmail account and open "Show original". SPF, DKIM and DMARC should all say PASS, and the DKIM line should name getacme.com.

One-click unsubscribe and 1:1 sales email#

Google requires one-click unsubscribe "only for marketing and promotional messages", and adds that "message recipients, not Google, determine the nature of the messages they receive." A cold sales email is promotional to the person receiving it. The requirement binds only bulk senders. But a recipient with no unsubscribe link has only the spam button left, and every spam report counts against you.

RFC 8058 defines the mechanism. List-Unsubscribe must contain an HTTPS URI, List-Unsubscribe-Post must read List-Unsubscribe=One-Click, and the DKIM signature must cover both headers. The POST carries no cookies, and the server must not answer it with a redirect.

OpenSequence adds both headers to every email it sends, and {{ unsubscribe_url }} renders the same signed link in the body. A click or a mail client's POST writes an email suppression and exits the enrollment at once, well inside Google's 48 hours and CAN-SPAM's 10 business days. If a body lacks the link, the sequence still publishes, with a NO_UNSUBSCRIBE warning instead of an error. Some teams drop the visible link to keep a 1:1 tone and rely on the headers plus a "reply 'no' and I'll stop" line. CAN-SPAM accepts a reply-based opt-out, so that choice is defensible. Google's bulk rules ask for a visible link. The details are in consent and suppressions.

The links point at SEQ_PUBLIC_URL, which must be public HTTPS (install guide). The engine signs each link with the first key in SEQ_ENCRYPTION_KEYS, and the link stays valid for 90 days. Rotating that key breaks the links in every email already sent. CAN-SPAM requires a working opt-out for 30 days after sending.

Volume per mailbox and ramp-up#

Workspace caps a user at 2,000 messages and 2,000 unique external recipients a day, over a rolling 24 hours, and 500 on a trial account (sending limits). Those caps exist to stop abuse. Plan well below them. Google's only ramp guidance is to "start with a low sending volume to engaged users, and slowly increase the volume over time."

OpenSequence defaults each sender's email channel to 30 sends in a rolling 24 hours, with at least 60 seconds between sends. Follow-ups count against the same cap. The ramp below is our practice, not a provider rule:

To change the cap, send PATCH /v1/senders/{id}/channels/email with {"daily_limit": 20} (senders). The enrollment preview staggers first touches by that cap, so at 30 a day, contact 31 starts the next day (enrolling). The API stores weekly_limit, but the executors do not enforce it yet.

Tracking pixels and link tracking#

OpenSequence v1 has no open or click tracking. Emails go out as plain text by default, with no pixel and no rewritten links. Click tracking rewrites every link to a redirect on another domain, so filters see a second domain in every message. Opens stopped being a reliable signal in 2021, when Apple's Mail Privacy Protection began helping users "prevent senders from knowing when they open an email."

You lose open-based branching and open alerts. Measure replies and meetings per 100 delivered emails instead. The analytics endpoints return both per sequence and per step. If you need click data, link to a page on your own domain with UTM parameters and read it in your web analytics.

Bounces, complaints and list hygiene#

The engine polls each sender's Gmail every minute. A message from mailer-daemon or postmaster with a delivery-status part counts as a bounce, and the engine matches it to the original by Message-ID. A 5.x.x status is a hard bounce. It suppresses the address for email and exits the enrollment with bounced. A 4.x.x soft bounce suppresses nothing.

The engine does not detect complaints. It handles a complaint signal, but the Gmail adapter never produces one, because Gmail gives individual senders no per-message complaint feed. Postmaster Tools is the only complaint view you get.

The engine does not verify addresses. Run your list through a verification service before you enroll. A new domain has no sending history to offset the bounces from a bad list. Report do-not-contact flags from your CRM as suppressed events (contact events). The engine only sees its own channels, so a contact marked "do not email" in your CRM keeps getting mail until you report it. Our rule of thumb is to stop email for the project when a batch bounces above 2%, then clean the list before turning email back on. To stop it, send PUT /v1/engine/flags/channel:email with {"value": false}.

What OpenSequence does and what you configure#

Pre-launch checklist#

For the rest of the move, see the guide to replacing your sales sequencing software and what building your own sequencer involves.

FAQ#

Do Gmail's bulk sender rules apply to cold email sent to business addresses?#

Not formally. Google says its sender guidelines do not apply to messages sent to Google Workspace accounts, and Microsoft's rules cover Outlook.com consumer addresses only. Most lists still include personal addresses, and business inboxes still filter spam, so meet the bulk rules anyway.

Is one-click unsubscribe required for cold sales emails?#

Google requires it from bulk senders for marketing and promotional mail, and says the recipient decides what counts as promotional. CAN-SPAM requires some opt-out in every commercial email, which can be a reply-based one. The List-Unsubscribe headers cost nothing, so send them on every message.

How many cold emails can one mailbox send per day?#

Workspace allows up to 2,000 messages a day per user, but that is an abuse limit. A new mailbox should start near 10 a day and grow to 30 to 50 over a month, counting follow-ups. Add mailboxes rather than raising the cap past that.

Should I send cold email from my main domain?#

No. Use a separate registered domain, because Google counts a subdomain toward your main domain's bulk sender status. If the cold domain gets blocked, your main domain's invoices and support mail keep arriving.

Does DMARC p=none satisfy the sender requirements?#

Yes. Google, Yahoo and Microsoft all accept p=none as the minimum, as long as SPF or DKIM aligns with the From domain. Microsoft recommends p=reject, so move to p=quarantine once your reports show only Google sending for the domain.

We build OpenSequence, an open source sales sequencing engine, so read this with that in mind. We also think most product-led teams should keep Customer.io and split the work between two tools. The rest of this post shows which jobs go where and how to connect the two.

Which tool for which job#

What Customer.io does well#

Customer.io is a messaging automation platform. You send it people and events through its SDKs, the Track API or Data Pipelines. An automation starts on an event, a segment or a schedule. That model fits lifecycle messaging. A user who created a workspace and never invited a teammate gets the "invite your team" email on day 3. A trial ending in 48 hours triggers an email and a push.

Its exit conditions cover the common cases too. An automation can exit people when a profile attribute changes, when they perform an event, or when they join a segment. So "stop the onboarding drip once they invite a teammate" is a checkbox, not code.

The pricing also fits lifecycle volume. As of October 2026, the Essentials plan starts at $100 a month for 5,000 profiles and includes 1 million emails. Push, in-app and webhooks are unlimited on every tier. If the job is "talk to the people using our product," keep it in Customer.io. We would not move that work.

Where it breaks for sales#

The email does not come from the rep's mailbox#

Customer.io can put the account owner's address in the From field. Its docs give that example. A Liquid statement as the from address resolves to each person's account manager and has a fallback for people who have none. The address has to resolve to a domain you verified in Customer.io.

That gets the right name on the email. It does not send from the rep's mailbox. The message leaves from Customer.io's servers or from a custom SMTP server you configure for the workspace. You can add up to six SMTP servers, but you assign each one to an automation type, either segment triggered, event triggered or transactional, and not to a person. The email never shows up in the rep's Sent folder. The rep's follow-up is a new message rather than a reply in a thread they own.

A sales email from max@acme.com sent through a marketing pipeline reads like marketing to the prospect. Their reply goes to an inbox Customer.io never reads.

Nothing stops on a reply#

Customer.io handles inbound messages for SMS and WhatsApp. As of October 2026 its messaging docs have no inbound pages for email. A reply goes to whatever address is in From or Reply-To, and Customer.io does not see it. The workaround on its community forum has four parts: a per-person Reply-To alias, a forwarding service like Zapier, a lookup that matches the sender to a profile, and a custom event that an exit condition listens for.

You can build that. But "stop following up when they answer" is the most important rule in sales email, and here it depends on four parts you maintain. When the Zapier step fails without an error, the prospect who said "yes, Thursday works" gets your day 5 bump anyway.

Calls and LinkedIn are tasks for a person#

A real sales sequence has steps a machine does not perform: call this person tomorrow, send a LinkedIn invitation, call again if they did not pick up. Customer.io has no task object for a rep. Its webhook action can push a task into your CRM. Your CRM then has to send the outcome, such as "voicemail", "connected" or "wrong number", back to Customer.io as an event before the automation can branch on it. You end up building a task queue next to Customer.io and keeping two state machines in sync.

There is no rep in the model#

Customer.io models people and objects. Sales sequencing also needs a sender: the rep a contact belongs to, the rep's mailbox and its daily cap, the rep's tasks. When a rep leaves, you need to know which running sequences were theirs. When an account executive takes over an account, the next email should come from them. Customer.io can store account_owner as an attribute and template it into From. It has no record that holds the rep's mailbox, caps it at 30 cold emails a day, or lists the rep's open calls.

Cold outreach violates the acceptable use policy#

This one is not about features. Customer.io's Acceptable Use Policy, revised November 2024, says emails "must be sent only to recipients who have explicitly opted in to receive content related to your brand." It adds that opt-ins "must be express and specific to your brand." It then lists prohibited recipient sources. You may not contact people whose information:

• was harvested or scraped from websites
• originates from purchased lists, "regardless of opt-in status"
• has been inactive or unengaged for two years or longer
• was obtained from partners or third-party organizations

An Apollo export, a Clay table and a conference attendee list all fall into those categories. The policy also states that an account "will be terminated if the user sends unsolicited email messages." A user-generated spam complaint rate at or above 0.1% over 30 days can lead to suspension. Sending to addresses obtained any other way than an opt-in "may incur a $100 (US) charge per substantiated incident (i.e. per email)."

Braze, Iterable and Loops are the same kind of product, a platform for messaging your own users. Read their terms before you upload a prospect list to any of them. The risk is losing the channel your onboarding email depends on.

Prospects count as billable profiles#

Pricing is the weakest argument here, but it is real. Customer.io bills by profiles, and it counts every profile that existed at any point in the billing period, including ones you deleted. As of October 2026 Essentials costs $100 for 5,000 profiles, $145 for 10,000, $235 for 20,000 and $325 for 30,000, with overage at $0.009 per profile. Load 15,000 sales prospects into a 5,000-user workspace and you move from the $100 tier to the $235 tier, even if you delete them a week later. The difference is small, and you pay it for people you should not email from Customer.io anyway.

Keep Customer.io for lifecycle, run sales next to it#

In the setup we recommend, Customer.io keeps sending every message to users, and a separate sales sequencer handles the cases where a rep should get involved. Both tools get the product events your app already emits.

This is how it works with OpenSequence. Each rep is a sender who connects their Google account once (Connect Google). Emails leave from their Gmail, and follow-ups can reply in the same thread. The engine polls that mailbox for replies in the threads it started. A sequence can mix email, a wait, a call task and a LinkedIn task. An opt-out or a hard bounce always exits the enrollment. A reply or a booking on the rep's calendar exits it when the sequence lists that event in exit_on.

1. Decide in your code who gets a human#

Your backend already sends track calls to Customer.io. The same code can apply a sales rule, for example "a workspace on a trial invited 3 or more teammates." OpenSequence has no auto-enrollment rules today. They are on the roadmap. Until then the rule lives in your code, which is where the definition of a product-qualified lead belongs anyway.

import { OpenSequence, OpenSequenceError } from '@opensequence/sdk';

const oseq = new OpenSequence({ baseUrl: process.env.SEQ_URL!, apiKey: process.env.SEQ_KEY! });

export async function onTeammatesInvited(user: User, workspace: Workspace) {
  if (workspace.plan !== 'trial' || workspace.invitedCount < 3) return;

  try {
    await oseq.sequences.enroll(process.env.PQL_SEQUENCE_ID!, {
      contacts: [{
        external_id: user.id,
        first_name: user.firstName,
        email: user.email,
        timezone: user.timezone,
        attrs: { workspace: { name: workspace.name, seats: workspace.invitedCount } },
      }],
      sender: workspace.accountOwnerId, // the rep's id in your app
      enrolled_by_kind: 'system',
    });
  } catch (err) {
    // One active sequence per contact: a rep already has this person.
    if (err instanceof OpenSequenceError && err.is('ALREADY_IN_SEQUENCE')) return;
    throw err;
  }
}

The enroll call upserts the inline contact before it creates the enrollment, so you need no separate sync job. It also refuses a contact who is already in any active sequence. That check keeps two reps from emailing the same trial user (Enrolling).

You could call the enroll endpoint from a Customer.io webhook action instead. We would not. Customer.io retries a webhook that returns 409 up to 11 times over about an hour, and here a 409 is a correct answer, not a failure. A ten-line handler in your backend can catch the 409 and return, as the code above does.

2. Pause Customer.io's drips while a rep works the account#

A trial user in a sales sequence should not also get the generic "upgrade now" drip. Register an OpenSequence webhook for enrollment.created and enrollment.exited (Receiving webhooks) and copy the state onto the Customer.io profile:

import express from 'express';
import { verifyWebhook } from '@opensequence/sdk';

const CIO_TRACK_AUTH = Buffer.from(`${process.env.CIO_SITE_ID}:${process.env.CIO_API_KEY}`).toString('base64');

app.post('/hooks/seq', express.raw({ type: '*/*' }), async (req, res) => {
  const event = verifyWebhook({ secret: process.env.SEQ_WEBHOOK_SECRET!, headers: req.headers, body: req.body });
  const { enrollment } = event.data as { enrollment: { contact: string } };
  const contact = await oseq.contacts.get(enrollment.contact);

  await fetch(`https://track.customer.io/api/v1/customers/${contact.externalId}`, {
    method: 'PUT',
    headers: { Authorization: `Basic ${CIO_TRACK_AUTH}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({ in_sales_sequence: event.type === 'enrollment.created' }),
  });
  res.sendStatus(204);
});

In Customer.io, add in_sales_sequence is true as an exit condition on the upgrade and nurture automations, and as a filter on their triggers. Nobody gets the generic drip while a rep is working the account. OpenSequence delivers each webhook at least once, in order per enrollment, so a handler that sets a boolean is safe to run twice.

3. Send events back to OpenSequence#

Some product events should end the sales sequence. If the user upgrades on their own, exit their enrollment with oseq.enrollments.exitMany({ contact: user.id, label: 'self-serve upgrade' }). If they unsubscribe in Customer.io, or your CRM marks them do-not-contact, report it as a contact event so OpenSequence suppresses them (Contact events). The engine only sees its own channels, so you have to report anything that happens elsewhere.

When someone opts out from a sales email, OpenSequence sends a signal.received webhook. Whether that also unsubscribes the person from product email is a policy decision for you and your counsel. Copying it to Customer.io's unsubscribed attribute is the conservative default.

What this costs you#

OpenSequence is headless. It has no inbox UI for reps, so you build the task list in your app or CRM (Tasks). You also run one container plus Postgres (Install). Today it sends email through Gmail only. SMTP and IMAP are on the roadmap. The project has not reached 1.0. If those trade-offs are wrong for you, the same split works with a hosted sequencer. Our guide to replacing your sales sequencing software compares the options, and building your own sequencer covers what you take on if you write the engine yourself.

When Customer.io alone is enough#

Stay on Customer.io alone if all of these are true:

• Every person you email signed up for your product, and none of the outreach is cold.
• A brand address, or an account manager's name on a verified domain, is acceptable to the reader.
• You do not need the email to stop the instant someone replies, because a reply goes to a human who handles it.
• There are no call or LinkedIn steps, or reps handle those outside any sequence.
• One person, usually a founder, does all the selling, so per-rep ownership and caps do not matter yet.

Plenty of early product-led companies fit that description. A "talk to the founder" email from Customer.io with the founder's name in From and a working Reply-To is fine. Add a sales sequencer when you hire the first rep whose job is to follow up with specific accounts, or the first time you want to email someone who has not signed up. That second case is also when deliverability becomes your problem rather than Customer.io's, so read up on cold email deliverability on your own infrastructure first.

FAQ#

Can I use Customer.io for cold email?#

No. Its Acceptable Use Policy requires an express, brand-specific opt-in and prohibits purchased, scraped and third-party lists, "regardless of opt-in status." It says Customer.io will terminate accounts that send unsolicited email, and it reserves a $100 charge per substantiated incident.

Can Customer.io send from each sales rep's email address?#

It can put the rep's address in the From header with Liquid, as long as you verified the domain in Customer.io. The email still leaves through Customer.io or a workspace SMTP server, not the rep's own mailbox. It does not appear in their Sent folder, and replies do not come back to Customer.io.

Does Customer.io detect email replies?#

Not for email, as of October 2026. It handles inbound SMS and WhatsApp. The common workaround for email routes a Reply-To alias through a service like Zapier. Zapier sends an event back to Customer.io, and an exit condition acts on it.

What is the difference between marketing automation and sales engagement?#

Marketing automation sends one brand's messages to many opted-in people, triggered by their behavior. Sales engagement runs a rep's personal outreach to specific people from the rep's mailbox. It adds tasks for calls and LinkedIn, and it stops when a human answers. The data model differs too. Marketing tools model the recipient. Sales tools model the rep and the recipient together.

What is a good Customer.io alternative for sales sequences?#

You probably do not need to replace Customer.io. Run sales sequences in a separate tool, either a hosted sequencer or a self-hosted engine like OpenSequence. Send the same product events to both, and sync a flag so the two never email the same person at once.

How much does Customer.io cost in October 2026?#

Essentials starts at $100 a month for 5,000 profiles and 1 million emails, billed monthly, with overage at $0.009 per profile and $0.12 per 1,000 emails. Premium starts at $1,000 a month billed yearly, and Enterprise is custom. Companies that have raised less than $10M can get the first year free through its startup program.

As of October 2026, lemlist's Email plan costs $55 a month, billed yearly, for unlimited users and 50,000 emails. That is about what hosting your own engine costs. Self-hosting saves money only against lemlist's Multichannel plan, which costs $87 per user per month billed yearly. So the reason to leave lemlist is rarely the email bill. It is where the data lives, who sets the limits, and whether sequencing should run inside your own CRM or product.

What lemlist does well#

lemlist's strongest feature is personalization. Its editor makes a custom image for each lead from a template. Text and lead-photo layers fill in {{firstName}} or {{companyName}}, or the editor pulls a per-lead image URL from a CSV column (lemlist help: create an image template). OpenSequence does not do that.

Deliverability tooling is the second strength. lemlist includes lemwarm, its warm-up network, in every plan, according to the FAQ on the pricing page. The plans also list a deliverability hub, inbox rotation, a custom tracking domain, DNS setup tests and deliverability alerts. lemlist connects Google, Microsoft and SMTP mailboxes.

The Multichannel plan adds SMS, an in-app dialer with a power dialer, and LinkedIn automation that covers profile visits, follows, invites, text and voice messages, and InMail. Every plan includes a database of more than 650 million leads and an email and phone finder. The comparison table also lists a unified inbox and AI detection of reply intent and out-of-office replies. A team that wants to find leads, email them and handle the replies in one tab gets all of that in one subscription.

lemlist pricing as of October 2026#

We took these prices from lemlist.com/pricing in October 2026. All prices are in USD.

lemlist prices the Email plan by volume, with unlimited users and senders. The usual per-seat argument for self-hosting does not apply to it. Multichannel is per user, so its price grows with headcount. Data costs extra. Lead enrichment starts at $20 a month for 2,000 credits, and buying-intent signals start at $29 a month for 100 signals. Both prices are for monthly billing.

What changes when you self-host#

OpenSequence is one Docker image and a Postgres database, version 14 or later. You register senders and contacts, publish sequences as versioned JSON, and enroll people over a REST API, the TypeScript SDK or the MCP server. Signed webhooks tell your app when someone replies, books a meeting or bounces. There is no UI. Your CRM or internal tool is the UI. The install guide covers a production setup.

You bring your own mailboxes, and today they must be Google#

lemlist also sends through your mailboxes, so the mailbox bill stays the same. What changes is who holds the connection. Each OpenSequence project registers its own Google OAuth client, and each rep consents once to Gmail and Calendar access (Connect Google). The Gmail API sends each email as the rep, and follow-ups appear in the same thread as the first email.

OpenSequence sends through Gmail only. It does not support Microsoft 365, and SMTP and IMAP adapters are in the "later" phase of the roadmap. If your reps work in Outlook, stop here and stay on lemlist.

Google classifies Gmail scopes as "sensitive". If every sender is in your own Workspace, an internal OAuth app needs no review. If any sender is outside your domain, Google has to verify the app before the consent screen stops showing them a warning.

You own the sending limits#

Every sender's email channel has a daily_limit, which defaults to 30 sends in a rolling 24 hours, and a min_gap_seconds, which defaults to 60. When a sender reaches the cap, the step waits an hour and the enrollment shows waiting_limit. Each sequence also has a send window in the contact's time zone. You change a rep's limits with one call (Senders):

curl -X PATCH $SEQ/v1/senders/u_42/channels/email \
  -H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
  -d '{"daily_limit":50,"min_gap_seconds":90}'

Enrollment spreads the first emails according to that cap. If you enroll 300 contacts for a rep with a cap of 30 a day, the first emails go out over ten days (Enrolling). Google's own limit is higher, at 2,000 messages a day per Workspace user and 500 on a trial account (Gmail sending limits). The cap that protects your domain is the number you set. No vendor algorithm changes it. The channel also stores a weekly_limit, but the executors do not enforce it yet.

Warm-up is your job#

OpenSequence is not a warm-up service and runs no warm-up network. A new mailbox on a new domain has no reputation, and a sequencer cannot give it one. You can buy warm-up separately. lemwarm sells standalone at $29 per mailbox per month, or $24 billed yearly, according to lemwarm.com/pricing. Or you can raise the volume by hand. We would start a new mailbox at a daily_limit of 10 and raise it each week while bounces stay low and Postmaster Tools shows no complaints. Our guide to cold email deliverability when you self-host covers the DNS records and the ramp.

Google sets the rules you must meet. Every sender to Gmail needs SPF or DKIM and a spam rate below 0.3% in Postmaster Tools. Senders of more than 5,000 messages a day to Gmail also need SPF, DKIM and DMARC, and one-click unsubscribe (Google's email sender guidelines). Every OpenSequence email includes List-Unsubscribe and List-Unsubscribe-Post headers at any volume. An opt-out, a hard bounce or a complaint suppresses the contact and exits the enrollment (Consent and suppressions).

LinkedIn becomes a task again#

This is the largest functional gap against lemlist Multichannel. OpenSequence does not automate LinkedIn. A LinkedIn step is a task. The rep gets "Connect with Dana on LinkedIn" with the profile link and a due date, does it by hand, and completes the task with an outcome. A linkedin_connect task completed as accepted resumes any step waiting on the connection. A linkedin_message task completed as replied counts as a reply in exits and analytics (LinkedIn steps).

We chose tasks because section 8.2 of LinkedIn's User Agreement forbids using "bots or other unauthorized automated methods to access the Services, add or download contacts, send or redirect messages". The account at risk is the rep's own profile. If we ship an automated adapter, it will be off by default behind a channel:linkedin_auto flag. It will need a written opt-in per sender, cap invitations per day and per week, and pause on any restriction signal. Anyone who turns it on still accepts that LinkedIn can restrict the rep's account. None of it ships today.

The data is in your Postgres#

Every enrollment, run, message, signal and task is a row in the seq schema of your database (Database). The API and the webhooks are the supported contract. The tables can change between minor versions before 1.0. For an ad hoc question, run a read-only query. This one counts replies and bounces per rep over the last 30 days:

select s.name,
       count(*) as enrolled,
       count(*) filter (where e.replied_at is not null) as replied,
       count(*) filter (where e.exit_reason = 'bounced') as bounced
from seq.enrollments e
join seq.senders s on s.id = e.sender_id
where e.mode = 'live'
  and e.enrolled_at > now() - interval '30 days'
group by s.name
order by bounced desc;

The service reads only the Gmail threads it started, and it stores reply bodies only when the project sets store_inbound_bodies. No third party holds a copy of your prospect list or your reps' replies.

Cost for 3, 10 and 25 senders#

A sender here is one rep with one Google Workspace mailbox. We assume each rep sends at most 60 emails per working day, so even 25 reps stay under 33,000 emails a month. That fits inside lemlist's smallest Email tier. Prices are per month, billed yearly where the vendor offers it, as of October 2026.

We sized the hosting ourselves on Render. A 2 GB web service at $25 runs the API and the workers in one container, and a 1 GB Postgres costs $19. At 25 senders we move to a 2 GB Postgres at $40. These are estimates, not benchmarks. Mailboxes are Google Workspace Business Starter at its list price of $7 per user per month on an annual commitment (Google Workspace pricing). You pay for mailboxes with lemlist too.

For email-only outbound, lemlist's Email plan costs about the same as hosting your own engine: $55 a month against $44 to $65. Once you add engineer time, self-hosting does not pay for itself on price there.

Against Multichannel, the gap at 10 reps is $826 a month, or about $9,900 a year. At 25 reps it is $2,110 a month. If you count mailboxes instead of reps, the gap shrinks. If 5 reps hold 5 mailboxes each, those 25 mailboxes need only 5 Multichannel users, or $435 a month.

The table leaves out engineering time. Someone has to deploy the container, register the Google OAuth client, set up DNS, connect each rep, and build the screens where reps see their tasks and enroll people. At $100 an hour, the $826 gap at 10 reps pays for about 8 hours a month. If your reps already work in a CRM or internal tool you control, that may be enough. If not, budget for building one. SMS and dialer calls go through Allo, which bills separately and is not in the table.

What you lose by leaving lemlist#

• A user interface. OpenSequence is headless, so you build the screens.
• Personalized images and lemlist's template library.
• Open and click tracking. OpenSequence counts replies and meetings only.
• A/B tests on content. A split node is on the roadmap, not in the code.
• Warm-up, inbox rotation and the deliverability hub.
• Microsoft 365 and SMTP mailboxes.
• LinkedIn automation, LinkedIn voice notes and WhatsApp.
• The lead database, the email finder and enrichment credits.
• A unified inbox. Replies stay in each rep's Gmail, and OpenSequence only detects them and exits the sequence.

In return, OpenSequence gives you things lemlist does not. Sequences are versioned JSON behind an API, so your product or an agent can create sequences and enroll contacts from code. Conditions can read a contact's open deal from Attio at decision time. A contact can be in only one active sequence per project. An enroll call that would break that rule fails with a 409 that names the conflict, so two reps never sequence the same person. OpenSequence stores the facts behind every branch decision.

Who should stay on lemlist#

lemlist is the better choice in any of these cases:

• Your reps send from Outlook or an SMTP server. OpenSequence cannot send through those mailboxes today.
• Email is your only channel. $55 a month for unlimited users is hard to beat with any server bill.
• LinkedIn automation brings in a large share of your pipeline, and your reps accept the account risk.
• Nobody on the team will own a container, a database and an OAuth client.
• You have no CRM or internal tool to act as the UI.
• Image personalization or the lead database is the reason you bought lemlist.

Self-hosting fits a narrower team. That team has engineers on staff and Google Workspace mailboxes, triggers sequences from its own CRM or product, and pays for several reps on Multichannel whose LinkedIn steps could be manual. If that is you, the migration guide for replacing your sequencing software covers the move. If you are weighing writing the engine yourself, read what it takes to build your own sales sequencer first. If you also pay Apollo for data, our Apollo alternatives post covers that part.

FAQ#

Is there an open source lemlist alternative?#

Yes. OpenSequence is open source under Apache-2.0, and you host it yourself. It covers the sequencing part: multi-step email from each rep's Gmail, SMS and call tasks through Allo, LinkedIn steps as manual tasks, and reply, bounce and opt-out detection. It does not include lead data, warm-up, image personalization or a user interface.

How much does lemlist cost in 2026?#

As of October 2026, the Email plan starts at $69 a month, or $55 billed yearly, for 50,000 emails with unlimited users and senders. Multichannel is $109 per user per month, or $87 billed yearly, with 5 senders per user. Enterprise pricing is custom. Data add-ons start at $20 a month for 2,000 enrichment credits.

Can I use lemwarm without lemlist?#

Yes. lemwarm sells standalone on lemwarm.com/pricing. As of October 2026, Essential is $29 per mailbox per month, or $24 billed yearly, and Smart is $49, or $40 billed yearly. lemlist also includes lemwarm in every lemlist plan.

Is LinkedIn automation against LinkedIn's terms?#

LinkedIn's User Agreement, section 8.2, forbids bots and other unauthorized automated methods that add contacts or send messages. LinkedIn can restrict the account that does it, which is the rep's own profile. That is why OpenSequence turns LinkedIn steps into tasks a person performs.

Does self-hosted cold email software improve deliverability?#

Not by itself. Inbox placement depends on the domain's and the mailbox's reputation, SPF, DKIM and DMARC, volume and complaint rates. Self-hosting gives you exact control over daily caps and gaps per mailbox, but it adds no warm-up. You still have to ramp up new mailboxes and watch Postmaster Tools.

Do I need Google Workspace to self-host OpenSequence?#

For email, yes. The email channel sends through the Gmail API with each rep's consent, and meeting detection reads Google Calendar. SMTP and IMAP support is on the roadmap for a later phase, with no date.

We build OpenSequence, so weigh this page with that in mind. We show every number's source and the assumptions behind our own column. We also list what the per-seat price buys that OpenSequence does not do, and the cases where Outreach or Salesloft is the better buy. We checked all prices in October 2026.

Neither vendor publishes a price#

The Outreach pricing page lists four Amplify packages and a "Request pricing" button on each. The Salesloft pricing page lists products and a "Talk to sales" button, with no tiers and no numbers.

That leaves three kinds of evidence. Vendr publishes aggregated contract data from the purchases it handles. Outreach sells one fixed package on AWS Marketplace with a visible price. Pricing roundups fill the gaps. Several of the ones we read cite each other or show medians computed from zero transactions, so we left them out.

Sources: Vendr on Outreach, Vendr on Salesloft (both updated February 2026) and the Outreach listing on AWS Marketplace.

Outreach#

The AWS Marketplace listing sells "Orchestrate (50 seats)" for $108,000 over 12 months. That is $2,160 per seat per year, or $180 a month. Orchestrate is an older package name, and 50 seats is more than our example team. Treat $180 as a reference point, not as your quote.

Vendr does not break Outreach down by seat. It reports the median contract and a range from $8,660 to $215,400. Volume discounts begin around 20 to 25 users. Add-ons such as Kaia, conversation intelligence and Commit can raise the contract value by 20% to 40%. Premium support costs 10% to 15% of the annual contract value.

Salesloft#

Vendr gives Salesloft a per-seat table, per user per month:

A 15-rep team is at Vendr's 10 to 15 seat minimum. That puts it in the Essentials buyer band, and it should expect to pay close to list on Advanced. Salesloft prices add-ons as a share of the base. Conversations, for call recording and transcription, adds 20% to 40%. Rhythm, for next-best-action, adds 15% to 30%, and Deals adds 10% to 20%.

What changed in 2025 and 2026#

Clari and Salesloft announced their merger on August 7, 2025, and closed it on December 3, 2025 with Steve Cox as CEO. The clari.com domain now redirects to salesloft.com, and the Salesloft pricing page lists Clari Forecast next to Cadence, Conversations, Deals and Rhythm. In practice, forecasting is now a line item on the same Salesloft quote. Ask for each product priced separately before you accept a bundle.

Outreach moved its site to outreach.ai and repackaged around AI credits. Its pricing page says the model "combines two models: seat-based access, where you pay for each user, and consumption-based AI credits, where you pay for what you use." Essentials includes 10,000 credits, Core 25,000, Plus 50,000 and Pro 100,000. Extra credit packs are for sale, and the page does not price them. Budget for credit purchases on top of seats, and ask what one credit buys before you sign.

Outreach and Salesloft for 15 reps#

Outreach at the AWS reference price is 15 × $180 × 12 = $32,400. With Vendr's 12% average negotiated saving it is $28,512. Vendr says volume discounts start at 20 to 25 users, so a 15-seat team is unlikely to get a price below that.

Salesloft Essentials, at what Vendr's 10 to 25 user buyers paid, is 15 × $60 × 12 = $10,800 to 15 × $85 × 12 = $15,300. Salesloft Advanced at list is 15 × $125 × 12 = $22,500 to 15 × $150 × 12 = $27,000.

Both vendors charge for onboarding. We use $5,000, the bottom of Vendr's range for both, because a 15-rep team rarely needs the enterprise package. We leave out add-ons and premium support. Those would raise the vendor totals by 20% or more.

Self-hosted costs, line by line#

OpenSequence is an Apache-2.0 sequencing engine that runs as one Docker image next to a Postgres you own. Our install guide covers the production setup. For our example team, the bill has four parts.

Hosting#

The scaling guide suggests 500 mCPU and 512 MB to start. It also estimates that 30 sequences with about 500 active contacts produce 5,000 to 15,000 step executions a day. For that load, one container with SEQ_ROLES=all and a small Postgres are enough. On Render's list prices:

That is $864 a year. On Fly.io, a shared-cpu-1x machine with 1 GB costs $6.70 a month and Managed Postgres starts at $38. The same setup there is about $45 a month.

Mailboxes#

OpenSequence sends each email through the rep's own Gmail account with the Gmail API. Outreach and Salesloft also send from the rep's mailbox, so this cost is the same in every column. Google Workspace Business Standard is $14 per user per month on an annual plan, so 15 × $14 × 12 = $2,520.

If every rep is in your own Workspace, you can make the OAuth client an Internal app. Google says Internal apps do not need verification, so you skip the review that Gmail's sensitive scopes trigger for outside users. The Google connection guide lists the four scopes.

SMS and calls#

OpenSequence sends texts and pushes call tasks to a power dialer through Allo. It has no Twilio integration today. A Twilio adapter is on the roadmap under "Later". On the Allo pricing page, Business is $32 per seat per month billed yearly and includes outbound SMS to US numbers, call recording and AI call summaries. The Power Dialer is $50 a month for the whole team, and 10DLC registration is $24 once.

For 15 reps that is 15 × $32 × 12 = $5,760, plus $600 for the dialer and $24 for 10DLC, so $6,384 in year one. Email-only teams skip this line.

Engineer time#

This is the largest cost, and you should replace our assumptions with yours. We assume a loaded rate of $100 an hour and these hours for year one:

OpenSequence has no user interface, so the 40-hour line is the easiest to underestimate. Your CRM or an internal tool has to show sequences, enrollments and tasks to reps. Year one comes to 128 × $100 = $12,800. Year two is maintenance only, 48 × $100 = $4,800.

12-month totals, side by side#

Every row is 15 reps and includes $2,520 for Google Workspace. Vendor rows include $5,000 onboarding in year one and Vendr's renewal uplift in year two, which is 3% to 7% for Outreach and 5% to 8% for Salesloft. Self-hosted rows include hosting and engineer time.

We put zero engineer hours on the vendor rows. Someone administers Outreach too, so this choice favors the vendors.

Against Salesloft Essentials, self-hosting saves $2,136 to $6,636 in year one. The savings grow in year two, when engineer time drops to maintenance, and they grow again with headcount. Each rep you add costs $720 to $2,160 a year in vendor seats, $0 in OpenSequence, and $384 in Allo if that rep texts.

What the per-seat price buys that OpenSequence does not#

The vendor price covers a finished application. Every Outreach package includes conversation intelligence. Core adds the Outreach Voice integrated dialer and call insights. Plus adds deal management, win and loss analysis, and meeting integrations with Zoom, Teams, Meet and Webex. Pro adds forecasting. Salesloft sells a dialer with local presence, Conversations for recording and coaching, Rhythm for next-best-action, Deals, and Clari Forecast.

OpenSequence does none of the following:

• It has no user interface for reps or managers.
• It does not record, transcribe or score calls. Allo records the calls it dials.
• It has no coaching, forecasting or deal management.
• It has no contact database and no mailbox warm-up.
• It sends email through Gmail only. SMTP and IMAP are on the roadmap, so Microsoft 365 teams cannot use it today.
• LinkedIn steps are tasks a rep performs by hand.

OpenSequence does the sequencing. It sends from each rep's Gmail and threads follow-ups. It applies daily caps per sender, send windows in the contact's time zone, and an 08:00 to 21:00 window for texts. It detects replies, bounces, opt-outs and meetings booked in Google Calendar, then exits the enrollment and sends a signed webhook to your app. How it works follows one contact through every step. The project is pre-1.0, and the SDK and MCP packages are not on npm yet.

When Outreach or Salesloft is the better buy#

Self-hosting is the wrong choice for many teams. Pay for Outreach or Salesloft if any of these apply:

• You have no engineer who can spend two weeks on setup and a few hours a month after.
• Your reps send from Microsoft 365.
• You want recording, coaching and forecasting on one contract with one vendor to call.
• Managers need dashboards and a sequence editor on day one.
• You have five reps or fewer. At that size the engineering hours cost more than the seats you would save.

Self-hosting is worth it when you already run your own CRM or product, your headcount grows, or you want sequences inside software you sell to customers. Our migration guide for replacing a sequencing tool covers the move. If you are weighing writing the engine yourself, read what it takes to build your own sales sequencer first.

How to bring a vendor quote down#

If you stay, Vendr's data points to five tactics. Multi-year terms of 24 to 36 months cut the effective annual price by 15% to 30% for both vendors. Ask for the renewal escalator in writing, since 3% to 8% a year compounds. Vendr suggests a 60 to 90 day notice window for auto-renewal, so put the date in a calendar 90 days ahead. On Outreach, ask how many AI credits your team will use and what the next pack costs. On Salesloft, get Conversations, Rhythm and Clari Forecast priced as separate lines before you accept a bundle.

For the cheaper end of the market, our Apollo alternatives comparison covers tools billed at $49 to $119 a seat.

FAQ#

How much does Outreach cost per user in 2026?#

Outreach does not publish prices. Its only public price is an AWS Marketplace package at $108,000 for 50 seats over 12 months, which is $180 per seat per month. Vendr's median Outreach contract is $45,600 a year across 919 purchases.

How much does Salesloft cost per user?#

Salesloft does not publish prices either. Vendr's data puts Essentials at $75 to $100 per user per month at list, Advanced at $125 to $150, and Premier at $165 to $200 or more. Buyers with 10 to 25 users paid $60 to $85 on Essentials.

Is Salesloft cheaper than Outreach?#

On Vendr's data, yes. The median Salesloft contract is $30,740 a year against $45,600 for Outreach, and Salesloft Essentials costs less than any Outreach reference price we found. For a 15-rep team, Salesloft Advanced at list costs close to Outreach.

Did Clari and Salesloft merge?#

Yes. They announced the merger on August 7, 2025, and closed it on December 3, 2025, with Steve Cox as CEO. Clari's site now redirects to salesloft.com, and Salesloft sells Clari Forecast as one of its products.

Do Outreach and Salesloft require annual contracts?#

Both sell annual or multi-year contracts, according to Vendr. Most Outreach contracts last 12 months, and 24 to 36 months is common for larger teams. Salesloft bills per user per month, paid annually or multi-year.

What does it cost to self-host a sales sequencer?#

For 15 reps on OpenSequence, expect about $864 a year in hosting on Render and $2,520 in Google Workspace seats you likely already pay. Engineer time is the largest cost, which we estimate at $12,800 in year one and $4,800 a year after. SMS and a dialer through Allo add $6,384 in year one.

We build OpenSequence, an Apache-2.0 open source sequencing engine you run yourself, so this guide uses it as the destination. Most steps apply to any target. For many teams, the better choice is to stay.

Who should not move#

OpenSequence is a headless engine that runs as one container with a Postgres database and an API. It is pre-1.0, and the SDK is not on npm yet. Stay where you are if any of these is true:

• Your reps send from Microsoft 365 or Outlook. OpenSequence sends through the Gmail API only. SMTP and IMAP are on the roadmap, not in the code.
• Nobody on the team writes code. OpenSequence has no UI. Someone has to build the enroll button, the task inbox and the reporting screen on the API.
• Your managers coach on open rates, click rates or A/B tests of copy. The engine tracks none of these. It counts only replies and meetings booked.
• You use Apollo mostly for its contact database, or lemlist mostly for lemwarm. OpenSequence is neither a prospect database nor a warm-up service.
• You need Salesforce or HubSpot sync on day one. The only CRM adapter is for Attio, and it reads from Attio but does not write to it. HubSpot is on the roadmap.

The teams who should move run Google Workspace, have an engineer, and want sequences inside their own CRM or product. If cost is the reason, read what Outreach and Salesloft cost or the Apollo alternatives compared first.

Inventory the features you use#

List the features your team used in the last 90 days. A sequence with no enrollments in a quarter does not need porting.

Any gap your team depends on is either work for your engineer or a reason to stay.

What each tool lets you export#

Every vendor makes contacts easy to export and sequence content harder.

Outreach. The export overview lists prospects, accounts, opportunities, calls, tasks, sequence states, users and emails as exportable. Instant downloads stop at 200 records, Outreach emails anything larger, and a filtered list caps at 100K. The same page says "Templates and Snippets cannot be exported." The REST API does expose sequences, sequenceSteps, sequenceTemplates, templates and snippets (common patterns), so a script can pull the content the UI cannot export. Export sequenceStates too. It tells you who is mid-sequence on cutover day.

Salesloft. Export people through GET /v2/people. POST /v2/cadence_export_downloads (docs) requests an export of the cadences the user can see. The export runs in the background, and Salesloft emails the file instead of returning it in the response. The cadence import docs show the JSON shape, with steps nested under cadence_content.step_groups[].steps[].

Apollo. Exporting saved contacts to CSV costs no credits. Exporting net-new contacts does (Apollo help center). For sequences, the search endpoint needs a master API key and a paid plan. It returns a step count, not the steps. Plan to copy step text by hand.

lemlist. The API exports a campaign's leads as CSV or JSON, filtered by state (export leads). The states include emailsUnsubscribed and emailsBounced, which together give you your suppression list. GET /campaigns/{campaignId}/sequences (docs) returns every step with its type, delay in days, subject and HTML message. lemlist is the easiest of the four to convert with a script.

Map sequences to definitions#

The mapping is mechanical. Each email becomes an outreach node, each delay a wait, each call or LinkedIn step a task, and "stop on reply" becomes exit_on. The sending schedule becomes settings.send_window. Merge fields become template paths such as {{ contact.first_name | "there" }}, and custom fields move into the contact's attrs.

Watch for three rules on your first publish. contact.first_name, contact.last_name and contact.email must carry a fallback or publishing fails with BAD_TEMPLATE. An email body without {{ unsubscribe_url }} publishes with the warning NO_UNSUBSCRIBE. Templates support only paths and fallbacks, with no conditionals or loops. Put any branching in a condition node.

Here is a typical five-touch Outreach sequence after translation. The snippet became a constant.

import { OpenSequence } from '@opensequence/sdk';

const oseq = new OpenSequence({ baseUrl: process.env.SEQ_URL!, apiKey: process.env.SEQ_KEY! });

// What used to be an Outreach snippet
const signoff = '{{ sender.first_name }}\n\nNot for you? {{ unsubscribe_url }}';

const definition = {
  schema_version: 1,
  entry: 'email_1',
  settings: {
    send_window: { days: ['mon', 'tue', 'wed', 'thu', 'fri'], from: '08:00', to: '17:00', tz: 'contact' },
    jitter: '15m',
    reenroll: 'never',
  },
  exit_on: ['reply', 'meeting_booked'],
  nodes: {
    email_1: {
      type: 'outreach', channel: 'email', action: 'send',
      params: {
        subject: 'Outbound at {{ attrs.company.name | "your team" }}',
        body: `Hi {{ contact.first_name | "there" }},\n\n…\n\n${signoff}`,
      },
      next: { sent: 'wait_1', skipped: 'wait_1' },
    },
    wait_1: { type: 'wait', params: { duration: '2bd' }, next: { then: 'email_2' } },
    email_2: {
      type: 'outreach', channel: 'email', action: 'send',
      params: { subject: 'Re: outbound', body: `…\n\n${signoff}`, reply_in_thread: true },
      next: { sent: 'call_1', skipped: 'call_1' },
    },
    call_1: {
      type: 'task',
      params: { kind: 'call', title: 'Call {{ contact.first_name | "them" }}', due: '2bd', expire: '4bd' },
      next: { completed: 'has_li', no_answer: 'has_li' },
    },
    has_li: {
      type: 'condition',
      params: { mode: 'all', rules: [{ field: 'contact.has_linkedin', op: 'is_true' }] },
      next: { yes: 'li_1', no: 'wait_2' },
    },
    li_1: {
      type: 'task',
      params: { kind: 'linkedin_connect', title: 'Connect with {{ contact.first_name | "them" }}', link: '{{ contact.linkedin_url }}', due: '1bd' },
      next: { completed: 'wait_2', no_answer: 'wait_2' },
    },
    wait_2: { type: 'wait', params: { duration: '3bd' }, next: { then: 'email_3' } },
    email_3: {
      type: 'outreach', channel: 'email', action: 'send',
      params: { subject: 'Closing the loop', body: `Hi {{ contact.first_name | "there" }}, last note from me.\n\n${signoff}` },
      next: { sent: 'end', skipped: 'end' },
    },
    end: { type: 'end' },
  },
};

const { ok, problems } = await oseq.sequences.validate(definition);
if (!ok) throw new Error(JSON.stringify(problems));

const { sequence, version } = await oseq.sequences.create({ name: 'VP Sales outbound', definition });
await oseq.sequences.versions.publish(sequence.id, version.id);

A connected call counts as a reply, so exit_on: ['reply'] ends the flow when a rep reaches the contact. 2bd means two business days in the contact's time zone, and it does not account for holidays. The full grammar is in the definition reference. Commit the file. From here on, every sequence change is a pull request. Published versions are immutable, so enrolled contacts finish on the version they started.

Mailboxes and warm-up continuity#

If your reps connected Google Workspace mailboxes to Outreach or Salesloft, you do not need to re-warm anything. OpenSequence sends through the same Gmail accounts by OAuth, from the same domain, with the same reputation. You do need your own Google OAuth client. Google classes Gmail scopes as sensitive. If accounts outside your Workspace domain use the app, Google must verify it before the consent screen stops warning users.

The trap is combined volume during the parallel run. OpenSequence's daily_limit defaults to 30 emails with a 60 second minimum gap, and it counts only OpenSequence's own sends. It cannot see what Outreach sent from the same mailbox an hour earlier. If a rep sent 50 a day before, split that budget. Put 35 in the old tool and 15 in OpenSequence in week one, then shift the split as the old sequences drain. Google's hard ceiling is 2,000 messages a day per Workspace user, and a cold outbound mailbox should stay far below it.

Secondary domains that lemwarm or another warm-up service warms are a different case. OpenSequence does not warm anything, so keep the warm-up service on those mailboxes or retire them. Confirm they are Google Workspace mailboxes before you plan around them.

Google's sender guidelines require SPF, DKIM, DMARC and one-click unsubscribe for senders above 5,000 messages a day to Gmail. They also require a spam rate below 0.30%, with 0.10% as the target. OpenSequence adds List-Unsubscribe and List-Unsubscribe-Post headers to every email. The rest is DNS work, which cold email deliverability when you self-host covers.

Run both systems without double-sending#

On any given day, a contact should be in exactly one system. OpenSequence returns 409 ALREADY_IN_SEQUENCE when you enroll a contact who is already in one of its sequences, but it cannot see Outreach. Your enroll code has to check the old tool too.

Drain the old tool instead of moving people. On cutover day, send new enrollments only to OpenSequence, and let contacts already in an old sequence finish in the old tool. Remove the old tool's "add to sequence" permission so nobody enrolls by habit.

Load suppressions before the first send. The API cannot remove a suppression, so get the list right.

// rows: unsubscribes and bounces exported from the old tool, keyed by your CRM id
for (let i = 0; i < rows.length; i += 500) {
  const chunk = rows.slice(i, i + 500);
  await oseq.contacts.batch(chunk.map((r) => ({ external_id: r.crmId, email: r.email })));
  await oseq.contacts.reportEvents(chunk.map((r) => (
    r.unsubscribed
      ? { contact: r.crmId, id: `import-optout-${r.crmId}`, type: 'opt_out', channel: 'email' }
      : { contact: r.crmId, id: `import-bounce-${r.crmId}`, type: 'suppressed', reason: 'invalid_email' }
  )));
}

Event ids make the import idempotent, so a rerun after a crash changes nothing. The contact events page lists every type.

Watch for replies on old threads. OpenSequence detects replies only in threads it started, so it does not see a prospect who answers an Outreach email from three weeks ago. While both systems run, forward any such reply as a reply event, or that contact keeps getting follow-ups.

Sometimes contacts must move mid-sequence, because the contract ends before the drain does. In that case, export their sequence state, remove them from the sequence in the old tool, and enroll them in a second published sequence whose entry is the step they had reached. Its first email cannot thread onto the old one, because reply_in_thread only threads within the same enrollment. Write that email as a new message that makes sense without the earlier thread.

Rehearse with mode: "dry_run" first. In dry-run mode, the engine records email and text steps with their rendered text instead of sending them. Waits, conditions and tasks run for real (enrolling).

CRM sync#

Outreach and Salesloft write activities into your CRM. OpenSequence writes nothing to it. You subscribe to signed webhooks and write what you want: run.done for a sent step, signal.received for replies, meetings and bounces, enrollment.exited with the reason, and task.created for your task inbox. OpenSequence retries each delivery for three days, and the same event can arrive twice. Make the handler idempotent on the event id.

The other direction matters more. Your CRM has to push do-not-contact flags, meetings booked in other tools, and deleted contacts back to OpenSequence. The engine never reads your database. If you skip this, it keeps emailing people your reps already excluded. Our tutorial on adding sales sequences to your own CRM has the code for both directions.

Reporting parity#

Open and click rates do not carry over. OpenSequence counts replies and meetings. It credits each one once per enrollment to the touch that earned it, within a 14 day window. It reports them per 100 enrolled and per 100 delivered, by sequence, step and channel.

Each vendor defines "reply rate" its own way, so do not compare dashboards. Before cancelling, export the old sequence stats and recompute replies per 100 enrolled for your top five sequences. Compare OpenSequence's numbers against that baseline after a month of sends.

Cutover checklist#

1. Confirm every sending mailbox is Google Workspace.
2. Export contacts, sequence states, step content and stats from the old tool.
3. Export unsubscribes, bounces and complaints, and load them as suppressions.
4. Deploy OpenSequence, register the Google OAuth client, and connect each sender.
5. Translate the live sequences, validate them, and run one dry-run enrollment each.
6. Build the webhook handler that writes activity to the CRM.
7. Build the task inbox for call and LinkedIn steps.
8. Add the old-tool check to your enroll code.
9. Split each mailbox's daily volume between the two systems.
10. Pilot with two reps on new contacts only.
11. Switch all new enrollments, and remove enroll rights in the old tool.
12. Forward replies on old threads as reply events until the drain ends.
13. Record baseline reply and meeting rates.
14. Cancel after the last old sequence finishes, and keep the exports.

A realistic timeline#

This is our estimate for a team of about 10 reps with one engineer working half time and sequences no longer than three weeks. It is not a measured benchmark.

The UI work in week 2 grows with every screen your reps expect. The drain lasts as long as your longest active sequence. Check your contract's notice period in week 1, because a missed auto-renewal date can lock you in for another term. If you are considering building your own engine instead, what it takes to build your own sales sequencer covers that option.

FAQ#

Can I import Outreach sequences into OpenSequence automatically?#

There is no built-in importer. Outreach's API exposes sequences, steps and templates. The mapping is mechanical, so a short script can turn them into definitions. Validate each definition with POST /v1/sequences:validate before publishing.

Will my deliverability drop when I switch tools?#

Not if reps keep the same Google Workspace mailboxes, because the sending account and domain do not change. The risk is the parallel period, when both tools send from the same mailbox. Split the daily budget between them.

What happens to prospects in the middle of a sequence?#

Let them finish in the old tool and enroll only new contacts in the new one. If you must move them, enroll them in a copy of the sequence that starts at the step they reached. Their next email starts a new thread.

Does OpenSequence work with Outlook or Microsoft 365?#

No. Email goes through the Gmail API only. SMTP and IMAP adapters are on the roadmap but not in the code.

Do I lose open and click tracking?#

Yes. OpenSequence has no open or click tracking. It measures replies and meetings booked, and attributes each one to a sequence, a step and a channel.

How long does a migration from Apollo or lemlist take?#

About four to six weeks for a small team with an engineer. lemlist is faster to convert because its API returns step content. You have to copy Apollo's step text by hand.