SmailPro APIsmailpro.com ↗
Create disposable Gmail addresses and read their inboxes via the SmailPro API. Two endpoints: create_email and get_inbox with full message arrays.
What is the SmailPro API?
The SmailPro API provides 2 endpoints for working with temporary Gmail addresses: create_email to generate a fresh disposable Gmail address and receive the credentials needed to access it, and get_inbox to retrieve all messages currently in that inbox. Each generated address comes with a key, email, and timestamp that are used to authenticate subsequent inbox requests.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/2d0d4e0e-bda3-44af-a03b-8e27ae62db29/create_email' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace smailpro-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
from parse_apis.smailpro_temporary_gmail_api import SmailPro, Email, Message
client = SmailPro()
# Create a new temporary Gmail address
email = client.emails.create()
print(email.email, email.timestamp, email.key)
# Check the inbox for messages
for message in email.inbox.list():
print(message.subject, message.from_, message.body)
Create a new temporary Gmail address. Solves a Cloudflare Turnstile challenge automatically and returns the email address, a timestamp, and a JWT key needed to check the inbox later. The email is valid immediately and can receive messages. Rate-limited to 3 active emails per session.
No input parameters required.
{
"type": "object",
"fields": {
"key": "string - JWT key for accessing the inbox",
"email": "string - the temporary Gmail address",
"timestamp": "integer - creation timestamp (Unix epoch seconds)"
},
"sample": {
"data": {
"key": "REDACTED_TOKEN",
"email": "[email protected]",
"timestamp": 1781128129
},
"status": "success"
}
}About the SmailPro API
Endpoints Overview
The API exposes two endpoints. create_email generates a new temporary Gmail address with no input parameters required. The response returns three fields: email (the full Gmail address, e.g. [email protected]), key (a JWT string), and timestamp (an integer). These three values together act as the session credentials for that address.
Reading the Inbox
get_inbox accepts key, email, and timestamp — all returned by create_email — plus a session_id and encryption_key. When using session chaining, the key, email, and timestamp parameters are auto-filled from session state, reducing the manual wiring between the two calls. The response returns the email field again alongside a messages array containing the inbox contents. Each element in messages is a message object representing a received email.
Session Chaining
The intended workflow is to call create_email first, then pass its output directly into get_inbox via session chaining. This makes it straightforward to automate sign-up-and-verify flows: generate an address, use it for registration on a third-party service, then poll get_inbox until the verification message arrives.
Coverage Notes
Addresses are Gmail addresses, which means they are accepted by most services that validate email domains. The API does not expose controls for choosing a specific username or domain — the address format is determined by the service. Inbox data reflects messages available at the time of the request; there is no streaming or webhook-based delivery notification.
The SmailPro API is a managed, monitored endpoint for smailpro.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when smailpro.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official smailpro.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Automate email verification steps in QA test pipelines using
create_emailandget_inboxin sequence - Generate a unique disposable Gmail address per test run to avoid state bleed across automated tests
- Extract OTP or confirmation codes from the
messagesarray during end-to-end sign-up flow testing - Bypass the need for a real email account when registering for third-party services in staging environments
- Check whether a service's welcome email arrives and contains expected content by inspecting inbox message objects
- Build a throwaway-email utility into a browser extension or developer tool using the two-endpoint workflow
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does SmailPro have an official developer API?+
What does get_inbox actually return in the messages array?+
messages field is an array of message objects representing emails received by the temporary address. The exact fields within each message object (sender, subject, body, received time) depend on what the service exposes. The email field at the top level confirms which address the inbox belongs to.Can I choose a specific Gmail username or alias when creating a temporary address?+
create_email takes no input parameters, so the generated address format is determined by the service. You can fork the API on Parse and revise it to add a parameter for requesting a specific username pattern if that capability becomes available upstream.Is there a way to send email or reply to messages through this API?+
How long does a generated email address remain active?+
get_inbox within a short time after create_email to avoid missing messages from short-lived addresses.