Loops Pricing Guide for 2026

Who this guide is for

This guide is for the SaaS team that wants one predictable number instead of a dashboard of meters: founders and small product teams whose email program is onboarding plus announcements plus transactional mail, and who would rather reason about audience size than reconcile send counts, contact tiers, and automation runs at month end. If your subscribed audience approximates your engaged user base — as it does for most product-led SaaS — then contact-based pricing maps to your business with almost no translation loss.

It also serves the evaluator who needs the caps explained before the promise. Loops' free tier binds on three verified numbers — 1,000 subscribed contacts, 4,000 sends in any rolling thirty days, and ten emails per second — while paid plans remove the send cap entirely and price from an on-page contact slider rather than a published ladder of tiers. Knowing which of those boundaries your program hits first is the whole decision, and that is what the sections below map using figures verified on September 17, 2026.

Loops' numbers are presented neutrally so the simplicity-versus-depth tradeoff can be judged on its own terms. For the full field before this single vendor, start at the pricing index.

Read this guide closely if

• You want unlimited sends on paid plans and a bill that moves only when the subscribed audience does.
• The whole team needs workspace access, and per-seat charges would distort a small team's budget.
• Transactional and marketing mail should draw from one plan rather than two contracts.
• You are close to the free ceilings and need to know exactly what changes at the paid step.
• Simplicity has genuine value: onboarding measured in hours, not quarters, is a requirement for you.
• Suppression hygiene is already disciplined, since unsubscribed records are free by construction.

Look elsewhere first if

• Native billing triggers from your payment processor are the first playbook you need live.
• Catalog, cart, and browse behavior should drive the majority of your flows.
• SSO, dedicated IPs, or warehouse-native journeys are procurement requirements now rather than later.
• A published fixed price ladder matters more than a slider-based quote for your approval process.

Those exclusions describe program shape, not product quality. Loops is deliberately narrow, and that narrowness is exactly what makes its pricing model legible — teams whose needs fall outside it will pay for capabilities here that another vendor includes, or miss capabilities they would rather buy elsewhere.

The billing model in one paragraph

Loops charges for subscribed contacts synced to the platform and does not charge separately for sending, which inverts the anxiety of per-email meters. Once on a paid plan, a team can run daily product updates, multi-step onboarding loops, and heavy transactional volume without watching a send counter, because the bill moves only when the subscribed audience grows. Unsubscribed contacts do not count toward the contact limit, so suppression hygiene and list cleaning directly hold the price down without deleting history anyone might need later.

The model maps cleanly onto SaaS growth because subscribed contacts approximate the engaged user base. Trials that convert, users who stay subscribed, and newsletter readers all occupy one intuitive meter, while dormant and unsubscribed records stop costing money. Forecasting becomes a single question, how fast does the subscribed audience grow, instead of a three-axis model balancing sends, contacts, and automation runs the way split-meter developer platforms demand.

Pricing geometry explained

Loops meters one thing: subscribed contacts synced to the platform. Sends are not metered on paid plans, transactional sending is included at no additional charge, and team seats cost nothing at every level — so the entire pricing model reduces to a single question with one variable. For an audience-based business that is a gift; for a volume-based one it is a constraint worth understanding before migration.

The definition of the meter matters as much as the meter itself. Unsubscribed contacts do not count toward the contact limit, which means suppression — normally a pure deliverability practice — becomes a direct pricing control as well. Every record you sunset or that opts out reduces the meter, while every engaged reader keeps it honest. The alignment between cost and engagement is unusually clean: you pay for people who agreed to hear from you.

Sends decoupled from price changes how a team behaves. On a per-send meter, every additional touch has a marginal cost, so frequency is rationed by the invoice. On Loops' paid model, a five-email onboarding loop, a weekly changelog, and a monthly broadcast to the same audience cost exactly the same as a single welcome email — provided the subscribed audience does not change. Cadence becomes an editorial decision rather than a financial one, which suits lifecycle programs and punishes nobody except the copywriter.

The free tier, by contrast, meters both contacts and sends: 1,000 subscribed contacts with up to 4,000 emails in any rolling thirty days, counting marketing and transactional together, at a throughput of ten per second with a small branded footer. That dual cap is temporary by design, and the paid step removes both — which is why the upgrade decision on Loops is triggered by contact growth rather than by send volume.

What a growing list does to the bill

A growing list raises the bill directly, because contacts are the only meter — but only the subscribed portion of it. A product adding 300 engaged readers monthly walks up the slider steadily, while a database accumulating dormant signups does not move the price unless those signups stay subscribed. The practical lever is therefore the same one deliverability teams already want: convert or unsubscribe, because ambiguous middle states are the expensive ones.

Forecasting follows from that single curve. Take current subscribed contacts, project the growth rate, and read the corresponding quote from the slider at signing and at twelve months; then stress the projection with a re-engagement campaign, since a winback push that converts the dormant half of the list will move the meter more than any ordinary month of growth. Nothing else in the model needs forecasting — no send allowance, no run count, no seat count.

The seventh row — free seats at every level — is easy to overlook and worth more than it appears: approval workflows where drafters, reviewers, and observers hold separate logins cost nothing extra on any Loops tier, which removes a common distortion in per-seat comparisons against otherwise similar tools.

The eighth row is the model's quiet advantage. On platforms where storage is metered, a suppression pass saves nothing; here it lowers the quote directly. Teams that treat list hygiene as a scheduled monthly ritual are therefore also running a cost-control program, whether they intended to or not.

Plan tiers, verified

The free plan is built for early products and smaller audiences: up to 1,000 subscribed contacts, up to 4,000 sends in any rolling thirty days across marketing and transactional mail combined, all features included, sending capped at ten emails per second, and a small Powered by Loops footer on outgoing mail. No credit card is required, and the whole team can be invited during evaluation since seats are free. A pre-launch SaaS with a few hundred beta users can run its entire welcome loop, changelog, and transactional mail inside this tier for months.

Paid plans scale on subscribed contacts with an on-page slider for estimates, keeping the same all-features-included posture while removing the send cap and the branded footer. Transactional email stays bundled rather than metered, throughput rises to 1,000 emails per second with excess queued automatically, and team seats remain free at every level. Because the vendor page prices by contact count rather than publishing a fixed ladder of named tiers in static text, teams should move the slider for their own audience size and treat the resulting figure as the quote, re-checking it at purchase time since packaging evolves.

Limits, overages, and the fine print

Loops' limits are refreshingly few, which is itself a finding worth stating. The free tier binds on two numbers: the 1,000-contact ceiling and the 4,000-send rolling window, plus the ten-per-second throughput rate. Crossing either means upgrading rather than paying per-unit overages, since the model has no per-email overage meter on paid plans at all. That absence of overages removes an entire category of invoice surprise that plagues per-send platforms during launch spikes and viral loops.

The rate limits deserve a practical read. Ten sends per second on free means a 4,000-recipient broadcast drains over six minutes, which is fine for lifecycle mail and irrelevant for urgency. Paid throughput at 1,000 per second clears a hundred-thousand-recipient launch in under two minutes. Emails beyond the rate are enqueued rather than rejected, so agents scheduling large sends need no special throttling logic, though time-sensitive sequences should still be modeled against the paid throughput before launch day.

Hidden fees and fine print

Loops' fine print is short because the model is short: no send meter, no per-seat charge, no automation-run meter, and no per-email overage anywhere in our verified source set. What remains are definitional details — how the free caps behave, what counts toward the contact meter, and how a slider quote becomes a contract — and those are worth pinning down before migration rather than after.

Rolling windows, not calendar resets

The free allowance is 4,000 emails in any rolling thirty-day window, not a monthly reset on the first. That distinction punishes back-loaded sending: two broadcasts near the end of a calendar month can sit inside the same rolling window and exhaust it together, even though each looks modest against a monthly view. Teams planning a launch should count backwards thirty days from the send date rather than forwards from the month's start.

The contact ceiling of 1,000 subscribed contacts is measured continuously, so growth is never a launch-day question — it is a trend line. Watch it weekly during active signup periods, because crossing the ceiling changes the plan obligation immediately rather than at renewal.

What counts toward the contact meter

Subscribed contacts are what the paid meter prices, and unsubscribed contacts do not count — a verified structural fact that makes suppression a pricing control. What should still be confirmed live is how the platform treats other record states: archived profiles, deleted-but-exported users, and contacts awaiting re-confirmation during a migration. None of these are exotic; all of them appear during a real list import.

Ask the question in writing: which record states consume a paid contact slot, and what happens to those slots the moment a suppression job runs. The answer determines whether a cleanup week costs money, saves money, or does both.

The slider quote is the price

Paid pricing follows an on-page contact slider rather than a published ladder of named tiers in static text, which means the number you budget is a quote captured at a moment in time rather than a list price you can cite from memory. Capture the slider figure for your current contact count and again for a projected count, note the date of both, and treat re-verification at purchase as mandatory rather than courteous.

The same applies at renewal and after any large import. Because the model has no published overage mechanics, the quote itself is the contract — which is simpler than metered billing and harder to reconstruct from old invoices if nobody recorded the inputs.

A practical habit follows: keep a one-line pricing log in the workspace — contact count, quote, date — updated whenever either changes. Two lines of bookkeeping prevent the entirely avoidable argument that happens when nobody can remember what the audience was when the number was captured.

Teams migrating from send-metered tools should also reset expectations about what a campaign costs here. The instinct to conserve sends, inherited from a per-email meter, is financially pointless on paid Loops and only survives as editorial judgment; what deserves the same instinct instead is the subscribed count, since that is the variable the slider reads.

Throughput, queueing, and the branded footer

Free sending runs at ten emails per second and paid throughput rises to a thousand per second, with volume beyond the rate enqueued automatically rather than rejected. Queueing is forgiving but not instant: time-sensitive sequences should be modeled against the paid throughput before launch day, and a large broadcast on free — 4,000 recipients draining over six minutes — should be scheduled rather than assumed.

The free tier also carries a small Powered by Loops footer, removed on paid plans. It is the only visible free-tier compromise, and alongside the removal of both caps it defines the paid step's entire value proposition: more audience, more mail, no branding, same features.

A pre-signing checklist

• Count subscribed contacts today, then project twelve months using your real signup and unsubscribe rates.
• Capture the slider quote for both figures and record the dates you captured them.
• Run suppression before migration so the meter starts at records worth paying for.
• Check rolling-window math against any planned launch or seasonal burst.
• Confirm which record states consume paid contact slots, in writing.
• Verify whether billing-triggered playbooks and revenue attribution are product gaps rather than tier gates.
• Re-verify everything at Loops pricing on decision day — all other figures here were verified September 17, 2026.

What the free tier really proves

Four thousand sends against one thousand contacts implies roughly four emails per contact per month, which fits the classic early-SaaS shape: a five-email onboarding loop for new trials, one monthly changelog, and transactional receipts. Because all features are included even on free, evaluation covers the real product rather than a gated demo, and the branded footer is the only visible compromise. Teams should use the free phase to prove event ingestion, loop timing, and deliverability on their own domain before growth forces the paid step.

The honest boundary is audience scale combined with lifecycle depth. A thousand subscribed contacts arrive quickly for any product with real traction, and the upgrade decision hinges on contact growth rather than feature gates. Programs needing billing-native dunning triggers, revenue attribution, or MCP-grade agent control will also feel the ceiling regardless of price, since those are product-shape gaps rather than tier gaps, covered in the comparison sections below.

Cost scenarios: three monthly windows

These three windows use only figures verified in this guide and the pricing index: the free tier's 1,000 subscribed contacts and 4,000 sends per rolling thirty days, the paid model's unlimited sends with included transactional mail and free seats, and the on-page slider that returns the paid quote. Where a dollar amount was not rendered in our sources, this guide states the shape of the cost rather than inventing the number.

Window two: steady state on free

A pre-launch SaaS holds 700 subscribed contacts and sends about 3,200 emails across a welcome loop, one monthly changelog, and transactional receipts, all inside the rolling window. Both free caps hold, the branded footer is the only visible compromise, and the invoice is zero dollars.

Because seats are free even here, the founder, a developer, and a contractor can share the workspace without a budget conversation — which matters more than it sounds during evaluation, when separate logins are usually the first thing a trial paywalls.

Window five: the first paid step

Signups lift the subscribed audience to 1,350, crossing the 1,000-contact ceiling, while monthly sending settles around 12,000 — comfortably past the 4,000-send window that governed free. The account moves to a paid step, both caps disappear, transactional sending remains included, and the quote comes from the slider at the current contact count.

Two things change structurally rather than numerically: sends are now uncapped, so cadence becomes an editorial decision, and the branded footer is gone. This guide does not state the dollar amount because our source set did not render one — capture the slider figure live, record the date, and re-check it before purchase.

Window nine: hygiene pays the bill down

The audience has grown to 1,900 subscribed contacts, but a suppression pass removes 600 dormant records that never re-engaged, leaving 1,300 — while monthly sending climbs to roughly 45,000 across multi-branch onboarding and weekly broadcasts, all still uncapped. The meter falls even as the program scales, because only subscribed contacts count.

This is the model's defining scenario: on a send-metered platform the same month costs more, on a contact-metered platform with different record rules it costs more still, and here a hygiene ritual produces a lower quote than growth produced a higher one. Pair the pass with an engagement-based sunset rule so the effect repeats every quarter rather than once.

The last row is the honest center of this table. Loops publishes its paid price through a slider rather than static text, so a guide bound to verified figures states the mechanics and asks you to capture the amount — the same convention our pricing index applies wherever a vendor did not render a base price.

For cross-vendor context, the verified alternatives in this comparison set price different axes: Sequenzy meters sends with free 2,500 monthly and paid plans from $19, Mailchimp's free tier covers 250 contacts with 500 sends, and Kit is free to 10,000 subscribers. Each answers a different growth question — and Loops' answer is simply how many subscribed readers you have.

Who Loops is for

Loops fits founders and small SaaS teams that want campaigns and lifecycle loops live this afternoon. It suits MVPs turning serious, side projects with early revenue, and product-led teams whose email program is onboarding plus announcements plus transactional, without dedicated lifecycle headcount. The free team seats make it natural for a founder, a developer, and a designer to share one workspace during validation.

Loops is a weaker fit for commerce sellers needing catalog-driven flows, for enterprises requiring SSO and dedicated IPs, and for data-heavy teams wanting warehouse-native journeys. Those buyers should weigh Klaviyo through our Klaviyo pricing guide, SendGrid through our SendGrid guide, or Customer.io through our Customer.io guide respectively.

Agent and MCP fit

Agents work with Loops through its sensible API and event ingestion rather than a native MCP server, which keeps integration effort low but governance custom. Pushing product events, triggering loops, and auditing audience state are all straightforward API operations an agent can perform under scoped keys. The operational win is the missing send meter: agents experimenting with onboarding variants cannot accidentally run up a per-email bill, so supervised testing is financially safe by construction.

Approval discipline still matters because financial safety is not reputational safety. An uncapped send allowance means a misconfigured agent loop can reach the entire subscribed audience without a billing tripwire stopping it first, so human approval on audience-wide sends, suppression checks, and loop re-entry rules remain mandatory. Our discussion scenarios on staging discipline and approval chains map these controls directly.

Loops versus a billing-first lifecycle tool

Loops wins simplicity while billing-first lifecycle tools add processor triggers and deeper orchestration. Loops' contact-based pricing with unlimited paid sends is the calmer model for teams that send frequently to stable audiences, and its onboarding curve is measured in hours.

The graduation path is legible: run Loops while loops themselves are the whole program, then compare Sequenzy head to head once billing events, dunning, multi-playbook orchestration, or agent-native operations become daily work. Developer-heavy teams may instead pair either lifecycle tool with a transactional API from our Resend guide or Postmark guide.

How it compares to Sequenzy for SaaS

Both platforms are SaaS-native and both refuse to tax dormant records in the way per-contact newsletter tools do — but they meter different things. Loops prices subscribed contacts and unmetered sends, verified as free 1,000 contacts with 4,000 sends per rolling thirty days and paid plans priced from an on-page slider with unlimited sends. Sequenzy prices sends with unlimited contacts, verified as free 2,500 emails per month, paid from $19 per month, and a $99 per 120,000 emails tier shown on its pricing page.

That difference decides the forecast. A team whose subscribed audience is stable but whose sending is frequent — daily product updates, multi-branch onboarding, heavy dunning — finds Loops' unmetered sends ideal and Sequenzy's send meter merely acceptable; a team whose stored database sprawls while sending stays modest finds the reverse, since Loops' meter counts every subscribed contact while the pooled model counts only what actually went out. Plot your two curves — subscribed contacts and monthly sends — and the cheaper geometry identifies itself.

The functional gap is lifecycle wiring rather than sending. Failed payments, trial expiries, and plan changes drive SaaS revenue directly, and they arrive as native billing triggers for Stripe, Paddle, and Lemon Squeezy on Sequenzy while requiring custom integration on Loops. The same is true of governed agent operation: MCP, CLI, and API access with approval primitives is a published capability on one side, and a conventional API requiring your own proposal-and-approve layer on the other.

Fairness also credits Loops where it earns. Onboarding measured in hours rather than weeks, all features included at every tier, free seats throughout, transactional sending bundled, and a pricing model a founder can hold in their head — these are real advantages for a small team whose alternative is not a richer platform but a slower one. Depth that arrives with a three-month implementation is not automatically better than depth that arrives on day one.

Where each one is the clear answer

Loops is the clear answer while loops themselves are the whole program: welcome flows, changelogs, transactional receipts, and a subscribed audience under or modestly above a thousand. The free tier genuinely covers that shape, the paid slider stays legible, and nothing about the model punishes experimentation.

A billing-first lifecycle tool becomes the clear answer when subscription events start driving the calendar — dunning flows, upgrade onboarding, and save flows — when the contact database outruns engagement, and when agent-run operations need MCP-native tooling under human approval.

A fair decision sequence

• Plot subscribed contacts and monthly sends separately over the next twelve months.
• Read the Loops slider at your current and projected contact counts, recording both dates.
• Price the same twelve months against the pooled anchors from our Sequenzy pricing guide.
• Add the custom billing-trigger integration cost to the Loops total wherever dunning matters.
• Add agent-governance build cost wherever assistants will touch production sending.
• Re-verify both live pricing pages before committing; this comparison is a September 2026 snapshot.

The structure above names each vendor's verified anchors and gaps plainly, leaving the decision on your two curves and your integration roadmap.

Loops questions and answers

What does Loops charge for?

Subscribed contacts, and nothing else that we could verify. Paid sends are unlimited, transactional sending is included at no additional charge, and team seats are free at every level.

Are there send overages?

No send overage meter appears in our verified sources: crossing the free caps means moving to a paid step, not accumulating per-email charges, and paid sending is uncapped in total with throughput up to 1,000 emails per second.

Do dormant records cost money?

Unsubscribed contacts do not count toward the contact limit, so suppression reduces the meter directly — though you should confirm live how awaiting-confirmation, archived, and other intermediate record states are treated.

How is the paid price determined?

Through an on-page contact slider rather than a published ladder of static tiers, so the quote is a captured figure tied to a contact count and a date rather than a list price you can quote from memory.

Does Loops include transactional sending?

Yes — transactional email is bundled on paid plans at no additional charge rather than metered separately, and marketing plus transactional sends share the same unmetered allowance.

How does it compare with pooled, per-email pricing?

Pooled models — including Sequenzy's verified free 2,500 monthly, paid from $19, and $99 per 120,000 emails tier with unlimited contacts — meter sends rather than audience, so the cheaper structure depends on which of your two curves is steeper.

Verdict and checklist

Choose Loops when SaaS-shaped simplicity beats platform depth, when the subscribed audience is under or near the free thousand, and when uncapped sends matter more than billing triggers. Validate free with real event ingestion, model the paid step on the contact slider at twice your current audience, keep suppression hygiene tight since unsubscribed records are free, and gate audience-wide agent sends behind human approval. Re-verify every figure at Loops pricing, compare the SaaS-native alternative in our Sequenzy guide, and return to the pricing index for the full verified set.

A thirty-day evaluation plan

The sequence below proves the model rather than the marketing, and it works whether you are starting fresh or migrating an existing list from a send-metered tool.

• Day one: connect the domain, confirm sending approval, and start a weekly subscribed-contact trend line.
• Week one: ingest real product events and run one welcome loop end to end with human approval.
• Week one: count rolling-window sends so the 4,000-send ceiling is measured, not guessed.
• Week two: send one broadcast to a genuine segment with suppression and test-render checks in front of it.
• Week two: confirm how each record state — subscribed, unsubscribed, awaiting confirmation, archived — counts toward the meter.
• Week three: run a suppression pass and observe whether the projected slider quote moves.
• Week three: stress the throughput assumption with a realistic audience-sized send and note queue behavior.
• Week four: capture slider quotes at your current count and at a projected count, recording both dates.
• Week four: price twelve months against the pooled anchors in the pricing index before committing.
• Day thirty: check whether billing-triggered playbooks are product gaps for your roadmap; if they are central, compare before migrating.
• Day thirty: re-read the live pricing page and purchase from today's quote rather than this guide's snapshot.

When to graduate from Loops

Three signals recur: billing events become daily work and the custom integration starts failing quietly; the subscribed audience outgrows the simplicity that made the slider attractive, and a pooled per-email model would bill less for the same program; or agent-run operations demand governed MCP-grade access and approval primitives that a conventional API cannot supply without your own governance layer.

None of the three requires urgency, and none invalidates the months spent here. They are invitations to re-run the comparison with fresh numbers — the same comparison this guide has tried to keep fair in both directions — and to move lifecycle work deliberately rather than by accumulated exception.

The graduation path most teams follow is legible: start on the free tier while loops are the whole program, move to a paid slider quote when the audience demands it, then re-evaluate once billing events, dunning, or agent operations become daily work. Pricing pages will have changed by then, which is exactly why every figure in this guide carries a verification date.

Where to go next

Start at the pricing index to place Loops' contact model beside every other verified vendor in the set, then read the 15-tool comparison for positioning context.

For the operating questions that pricing pages never answer — who approves what, how staging differs from production, how cost gets attributed per agent run — take the thirty-eight editorial discussion threads, starting with approval chains, staging versus production sends, and cost per agent run.

Use the neighboring guides for different operating shapes: Sequenzy for pooled lifecycle sends with billing triggers, Postmark for traceable transactional delivery, Customer.io for profile-led behavioral journeys, and Brevo for a broader multi-channel budget tool.

The closing discipline is identical whichever meter you choose: forecast your own growth curve, keep suppression tight, gate consequential sends behind a human, and let the live vendor page overrule this September 17, 2026 snapshot at the moment you actually pay.

Open pricing index