Phonekit vs Mailosaur for SMS testing

Compare the two

Mailosaur details come from its public site, docs and pricing page as of November 2026.

Choose Mailosaur when

• You test email and SMS and want both in one tool and one API.
• You need test numbers in the UK or Canada, or premium numbers in other countries.
• Your tests are written in Java, Ruby, Python, .NET, PHP or Go and you want a native client.
• You want email previews or deliverability checks alongside your SMS tests.

Choose Phonekit when

• A service your product depends on only texts mobile numbers. Phonekit Mobile numbers are real SIM lines on a mobile network.
• Coding agents need to read codes while they work on your own app. They can use the agent skill, MCP server, CLI, SDK or API.
• Your team shares numbers. Each number has its own list of people, test keys and agents, and everyone sees messages in one shared inbox.
• You run tests in parallel. Give each worker its own number and mark it before the text is sent, so a test only reads the code it asked for.
• You test a product that texts people. Phonekit can text your own numbers, your teammates' verified phones, anyone who texted you in the last 30 days and up to five numbers you add, at 10 texts a minute and 100 a day per number.

No number is accepted by every service. Some services only text mobile numbers, and that is what Mobile lines are for. Phonekit is for testing and running your own product, not for verifying accounts on other services.

The same Playwright test in each tool

Both tests sign in to the same app: fill in the phone number, ask for a code, read it and submit it. The Mailosaur calls are the ones its Playwright SMS docs show: messages.get() with sentTo, and the code from message.text.codes.

import { test, expect } from "@playwright/test"
import MailosaurClient from "mailosaur"
 
const mailosaur = new MailosaurClient(process.env["MAILOSAUR_API_KEY"]!)
 
test("signs in with the SMS code", async ({ page }) => {
  const phoneNumber = process.env["TEST_PHONE_NUMBER"]!
  await page.goto("/signin")
  await page.getByLabel("Phone number").fill(phoneNumber)
  const receivedAfter = new Date()
  await page.getByRole("button", { name: "Send code" }).click()
  const message = await mailosaur.messages.get(
    process.env["MAILOSAUR_SERVER_ID"]!,
    { sentTo: phoneNumber },
    { receivedAfter, timeout: 120_000 }
  )
  const code = message.text?.codes?.[0]?.value ?? ""
  await page.getByLabel("Verification code").fill(code)
  await page.getByRole("button", { name: "Verify" }).click()
  await expect(page).toHaveURL(/\/account/)
})

import { test, expect } from "@playwright/test"
import { Phonekit } from "@phonekit/sdk"
 
const phonekit = new Phonekit({ apiKey: process.env["PHONEKIT_API_KEY"]! })
 
test("signs in with the SMS code", async ({ page }) => {
  const phoneNumber = process.env["TEST_PHONE_NUMBER"]!
  const number = phonekit.number(phoneNumber)
  await page.goto("/signin")
  await page.getByLabel("Phone number").fill(phoneNumber)
  const after = await number.mark()
  await page.getByRole("button", { name: "Send code" }).click()
  const code = await number.waitForOtp({ after, timeoutMs: 120_000 })
  await page.getByLabel("Verification code").fill(code)
  await page.getByRole("button", { name: "Verify" }).click()
  await expect(page).toHaveURL(/\/account/)
})

The two are close in length. The differences are in the details:

• Waiting. Mailosaur's Node client waits 10 seconds by default and searches the last hour unless you pass receivedAfter. Pass both, as above, for a fresh code and a realistic wait. Phonekit's waitForOtp() needs a deadline every time.
• Fresh messages. receivedAfter is a time from the test machine. Phonekit's mark() is a position recorded on Phonekit's side, so the wait doesn't depend on two clocks agreeing.
• Types. Mailosaur's docs read message.text.codes[0].value. In its TypeScript types those fields are optional, so a strict project checks them as shown. Phonekit's waitForOtp() returns a string, or throws missing_otp when the text has no code.

The Playwright guide has the complete Phonekit test, and one number per parallel test covers resends and parallel workers.

Sources

As of November 2026:

• Mailosaur SMS testing page and SMS testing docs: email and SMS in one product, and the client libraries.
• Mailosaur phone numbers docs: standard numbers in the UK, US and Canada, each dedicated to your account.
• Mailosaur Playwright SMS guide: messages.get() with sentTo, receivedAfter, and codes in message.text.codes.
• Mailosaur Playwright quickstart: npm install mailosaur and new MailosaurClient(...).
• Mailosaur Node client source: messages.get() waits 10 seconds and searches the last hour by default, and text.codes is optional in its types.
• Mailosaur pricing: Personal from $20 and Core from $50 a month billed annually, and "SMS and authentication from $37.50 per month" listed on Core.
• Phonekit pricing and the SDK reference.