Unipile and Lumbox both appear in lists of email APIs for AI agents, but they answer different questions. Unipile connects accounts your users already have, across email and messaging apps, and lets your product act inside them. Lumbox creates new email addresses that belong to your agents. The Unipile details below come from its pricing page and its email API guide as I read them in September 2026.

What Unipile does

Unipile is one REST API over many channels: LinkedIn, WhatsApp, Instagram and Telegram for messaging (X and Messenger are listed as coming soon), Gmail, Outlook and IMAP for email, and Google and Outlook calendars. Your end user links an account through a hosted, white-label auth flow. Unipile stores and refreshes the OAuth tokens, your app gets a stable account ID, and every provider's email comes back in the same schema. Webhooks cover new messages, account status changes, and open and click tracking on email.

Sending goes out through the user's real mailbox. Unipile's guide puts it simply: alice@gmail.com sends as alice@gmail.com, and the message lands in her Sent folder. For a CRM, an applicant tracking system or a sales tool, that is the whole point, because replies come back to a person who already has a relationship with the recipient.

How Unipile connects varies by channel, and its FAQ is open about it. Email and calendar use official APIs (the Gmail API, Microsoft Graph, IMAP), as does Telegram. LinkedIn, WhatsApp and Instagram work "through reverse engineering," with Unipile acting as a technical intermediary for actions the user initiates. If your product depends on those channels, read that part of their documentation before you build on it.

Pricing is per linked account, whatever the channel. The minimum is €49 or $55 a month for up to 10 accounts; from 11 to 50 accounts every account is billed at $5.50 a month, and the per-account rate falls to $3.50 above 5,000. API calls are unlimited, prices exclude VAT, and there is a 7-day trial without a card. The pricing page also lists an official SDK, an MCP server, and n8n and Make integrations.

What Lumbox does

Lumbox creates the address. POST /v1/inboxes returns something like research-bot@trylumbox.com, or an address on your own domain once it is verified. Mail that arrives is parsed immediately (parsed.otp_codes, verification_links, magic_links, category), and the agent can block on /wait or /otp until the email it needs shows up. The same inbox sends, replies with correct threading headers, and forwards. There is a REST API, SDKs for TypeScript and Python, webhooks, and an MCP server with more than 80 tools. Plans are priced by inbox count: 3 inboxes free, then 10 for $9, 50 for $29 and 250 for $99 a month, each with monthly received and sent allowances.

The real difference: whose address is it?

With Unipile, every address is someone's existing account, and your software uses it with that person's consent. That is exactly right when an agent works for a human: triaging their inbox, drafting follow-ups, logging candidate emails.

It is awkward when the agent needs an address of its own. Unipile has nothing to link until an account exists, so you would first create a Gmail or Outlook account for the agent. For Gmail that runs into Google's account policy, which says not to use programs to create accounts and that Google detects and disables accounts made for abuse. You could link a mailbox from another provider over IMAP, but then you are provisioning mailboxes somewhere else and paying Unipile per mailbox to reach them.

With Lumbox there is no end user in the picture. The agent's address exists because your code made it, and a DELETE removes it when the task is finished:

BASE=https://api.lumbox.co/v1

# create an address for this task
curl -s -X POST $BASE/inboxes -H "X-API-Key: $LUMBOX_API_KEY" \
  -H "Content-Type: application/json" -d '{"name":"supplier-portal"}'
# {"id":"inb_...","address":"supplier-portal@trylumbox.com","status":"ACTIVE",...}

# block until the portal's verification code arrives (up to 120 seconds)
curl -s "$BASE/inboxes/inb_.../otp?timeout=120&from=portal.example" \
  -H "X-API-Key: $LUMBOX_API_KEY"
# {"code":"482913","all_codes":["482913"],"email_id":"eml_...",...}

# retire it
curl -s -X DELETE $BASE/inboxes/inb_... -H "X-API-Key: $LUMBOX_API_KEY"

Lumbox's parser is regex, not a model. On received mail it finds 4 to 8 digit codes in the subject and plain-text body, so a code with letters in it means reading the email from /wait and extracting it yourself.

What each one counts

Because the two products price different things, a direct cost comparison only makes sense for a workload both can do. Take 40 identities that need email. On Unipile that is 40 linked accounts at $5.50, or $220 a month before VAT, and each of those accounts could also be a LinkedIn or WhatsApp account at the same rate. On Lumbox, 40 inboxes fit the Pro plan at $29 a month, which also includes 25,000 received and 10,000 sent emails. Lumbox has no LinkedIn, WhatsApp or calendar support at any price, so if you need those channels the comparison ends there.

Pick Unipile if

  • Your end users connect their own accounts and your product acts on their behalf.
  • You need more than email: LinkedIn, WhatsApp, Instagram or calendars through one API.
  • Mail must come from the user's real address and appear in their Sent folder.

Pick Lumbox if

  • The agent needs an address of its own, created and deleted by code.
  • You want verification codes and links parsed on arrival, and a call that waits for them.
  • You would otherwise be creating Gmail accounts for bots.

Using both

The two do not overlap much, so one product can use both without conflict. A sales tool might let reps connect their Gmail and LinkedIn through Unipile for outreach, while its own background agents use Lumbox addresses to register for data sources and receive vendor notifications. Keeping those identities separate also keeps the reps' mailboxes out of whatever the background agents sign up for.

For more on the agent-owned side, giving an agent an email address walks through the setup, the Gmail API comparison covers the user-mailbox side in more depth, and the quickstart shows the create and wait steps with both SDKs.