Temporary Email Inbox & OTP API for AI Agents

Create a private temporary email address, receive test emails and extract numeric verification codes as JSON. Use it for authorized QA of email verification flows, staging applications, n8n workflows and AI agents. The inbox receives real SMTP email; each inbox belongs to the Apify account that created it.

No separate HirePulse account, API key or crypto wallet is needed. Billing is handled by Apify. This Actor receives email; it does not send email, register accounts or complete verification on other websites. Temporary email domains may be rejected by external services.

Watch the workflow

11-second sequence of actual Apify Console screenshots from successful owner test runs: create → pending → code → delete. The disposable test email was injected through the signed relay, not sent over SMTP; this clip demonstrates the Actor and backend workflow. Waits are trimmed, and the private account sidebar and mailbox capability are excluded. Owner test-run usage shown in the Console is not the customer price; see pricing below.

Quick start

Run with:

{"action":"create","ttl_seconds":600}

The Actor returns immediately with a private random email address, inbox_id, capability and expires_at. Send your authorized test email to that address using your application's normal email flow. Then run this Actor again from the same Apify account:

{
  "action":"get_code",
  "inbox_id":"REPLACE_WITH_INBOX_ID",
  "capability":"REPLACE_WITH_PRIVATE_CAPABILITY",
  "wait_seconds":30
}

The capability field is marked as a secret input. Never paste a real capability or verification code in a public Issue, support screenshot, task example or shared dataset.

What you can do

Action	Result	Requirements
create	Random inbound address, inbox ID, private capability and expiry	ttl_seconds from 60 to 3600; default 600
get_code	Numeric candidate with provenance, or an explicit pending/no-code/ambiguous state	Inbox ID and capability; optional wait up to 30 seconds
list_messages	Up to 50 message metadata records; no raw body, sender, subject or attachments	Inbox ID and capability
delete	Delete live inbox message candidates and revoke further reads	Inbox ID and capability

Pricing and spending limits

Every Actor start costs $0.001, including read, list, delete, invalid-input and failed runs. Creating an inbox additionally costs $0.01 per started 10 minutes of requested lifetime. There is no charge per received message or extracted code. Standard run compute is covered by these event prices; post-run storage/API usage follows Apify's platform pricing.

Operation	Total event price
Create an inbox for 1–10 minutes	$0.011
Create an inbox for 11–20 minutes	$0.021
Create an inbox for one hour	$0.061
One get-code run, with up to 30 seconds waiting	$0.001
One list-messages or delete run	$0.001

Set maxTotalChargeUsd to at least $0.011 for a 10-minute create run or $0.061 for one hour. The Actor checks this limit before allocation. Creation retries within the same Actor run reuse the same inbox; they do not deliberately allocate or charge a second inbox. Starting a new create run creates another inbox and incurs its own fee. An uncertain charge is not automatically submitted again.

You buy a time-limited inbound address, not guaranteed email delivery or a working OTP. An inbox with no arriving email still incurs the allocation charge. No automatic no-message refund is implemented.

Output examples

Create (illustrative values only):

{
  "action":"create",
  "status":"active",
  "inbox_id":"00000000000000000000000000000000",
  "address":"example-only@example.invalid",
  "capability":"REDACTED_PRIVATE_CAPABILITY",
  "expires_at":1900000600,
  "allocation_price_usd":0.01,
  "run_start_price_usd":0.001
}

No email yet:

{"action":"get_code","inbox_id":"00000000000000000000000000000000","status":"pending","code":null,"provenance":[],"run_start_price_usd":0.001}

When a supported numeric code is found, status is code, code contains the candidate and provenance contains its message ID, receipt/expiry timestamps, source: "signed_relay", sender_verified: false and extraction method. SMTP sender identity and code validity are not verified.

Input reference

• action: create (default), get_code, list_messages, or delete.
• ttl_seconds: integer 60–3600; default 600; used by create only.
• inbox_id: 32 lowercase hex characters; required for an existing inbox.
• capability: 64 lowercase hex characters; required for an existing inbox; encrypted secret input.
• message_id: optional 32-character ID from metadata; selects one message for get_code.
• wait_seconds: integer 0–30; default 0; get_code only. Polling is bounded and sleeps between requests.

Code extraction and statuses

The parser conservatively recognizes 4–8 digit numeric codes near verification/security/one-time-code/OTP labels, including supported Hebrew verification labels. Plain text and HTML text are parsed; scripts and attachments are not executed. Alphanumeric codes, magic links, QR codes, arbitrary email text and attachments are not returned.

• pending: no retained message candidate yet.
• no_code: retained message has no supported code.
• ambiguous: more than one candidate; use list_messages and select message_id when appropriate.
• code: one numeric candidate; verify suitability in your authorized application.
• Expired/deleted inboxes fail with inbox_expired_or_deleted; wrong account or capability fails without exposing another account's mailbox.

Privacy and retention

Backend ownership is derived from the platform's Apify user ID, never an input field. Both the default dataset and key-value store are explicitly set to RESTRICTED before any inbox credential or code is persisted. The Actor fails if these permissions cannot be applied. Results are stored only in your run's restricted output, dataset and recovery state; operational logs omit addresses, capabilities, message bodies and codes. Users with explicit access to your Apify resources may still read them, so do not share sensitive run access.

Inbox lifetime is at most one hour. Retained code candidates expire after at most five minutes, or earlier when the inbox expires or is deleted. The backend does not retain full message bodies. Apify copies of results follow Apify storage retention, which can outlast the inbox lifetime; deleting a mailbox does not delete previous Apify run output. Remove sensitive run storage when no longer needed. Provider recovery snapshots may outlast live deletion.

Limits per Apify account: 20 active inboxes, 1000 retained inbox records, 50 distinct messages per inbox and 120 backend requests per minute. Retry 429/temporary errors with backoff. No arbitrary recipient name or custom domain is accepted.

API, MCP and n8n

Run through Apify API with your Apify token in an Authorization header:

curl -X POST 'https://api.apify.com/v2/actors/hirepulse~temporary-email-inbox/run-sync-get-dataset-items?timeout=90&maxTotalChargeUsd=0.011' \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"action":"create","ttl_seconds":600}'

For Apify MCP, select this Actor:

https://mcp.apify.com?tools=hirepulse/temporary-email-inbox

For n8n or Make: create inbox → save the returned ID/capability in private workflow credentials/state → trigger your authorized application's test email → call get_code with wait_seconds 30 → consume the candidate → delete inbox. Do not loop rapidly with new Actor runs; each run has the $0.001 start fee. Exported workflow examples must contain placeholders only.

Troubleshooting and support

• pending: confirm the recipient is the allocated address and the inbox has not expired; external delivery may be delayed or rejected.
• no_code: the message may contain a link or an unsupported code format.
• ambiguous: inspect message metadata and choose a message ID; do not guess between candidates.
• inbox_not_found: check the Apify account, inbox ID and capability together.
• run_budget_too_low: increase the run limit to cover the stated event price; the automatic start fee still applies.
• private_storage_required: restricted storage access could not be confirmed; no mailbox allocation is attempted.
• billing_confirmation_pending: keep the run ID and contact support through the Actor Issues tab without posting credentials. Do not retry by creating multiple paid inboxes.

Use for systems and email flows you own or are authorized to test. Support is available in the Actor's Issues tab. Include the action and safe error code, not the mailbox capability, message contents, Apify token or OTP.