You need disposable Gmail-style addresses you can generate on demand, feed into tests, sign-up flows, or QA scripts, and you need it this week. By the end of this article you’ll be able to generate a single temporary Gmail address, bulk-generate up to 500 unique addresses with dot/plus rules, and check the inbox activity for a given address—using one API key from Zyla API Hub.
What this API does and when to use it
The Temporary GMail API provides programmatic generation of temporary Gmail-compatible addresses and a way to inspect recent inbox activity for verification checks. Typical use cases include:
- End-to-end tests that require unique Gmail-formatted addresses on each run.
- Seeding demo environments with realistic, deliverable-style emails.
- Creating parallel sign-up flows that exercise dot-and-plus address behaviors.
- Polling recent activity for verification steps in staging.
The API runs on Zyla API Hub, so you use a single API key, consistent Authorization headers, and a subscription + quota model across the entire marketplace.
Getting started on Zyla API Hub
Open the Temporary GMail API page on Zyla, subscribe, and grab your key. Authentication is a standard bearer token.
- Go to the marketplace listing: Start 7-day trial on Temporary GMail API.
- Click Subscribe (or Start Free Trial when available) to get your key.
- Send requests with: Authorization: Bearer YOUR_API_KEY.
Zyla uses subscription + quota (not pay-per-call). Check the API page for current access options and pricing. Your key works across more than 10,000 public APIs on Zyla API Hub.
Endpoints you’ll use
All endpoints below are HTTP GETs on Zyla’s hub URLs and require the Authorization header. Only the documented parameters should be sent.
1) Generate Gmail
Generates a single temporary Gmail address.
- Method: GET
- URL: https://zylalabs.com/api/8382/temporary-gmail-api/14645/generate-gmail
- Required params:
- domain (string): random
cURL (copy-paste ready):
curl -s -X GET "https://zylalabs.com/api/8382/temporary-gmail-api/14645/generate-gmail?domain=random" \
-H "Authorization: Bearer YOUR_API_KEY"
Example JSON response:
{
"email": "[email protected]"
}
Fields you’ll actually use:
- email: the generated Gmail-style address you can immediately plug into signup or test flows.
2) Bulk GMail
Generates up to 500 unique temporary emails with optional dot/plus/domain filters.
- Method: GET
- URL: https://zylalabs.com/api/8382/temporary-gmail-api/14647/bulk-gmail
- Params:
- dot (string, optional): true
- plus (string, required): false
cURL:
Example JSON response:
Notes:
- count: number of emails returned in this batch.
- emails: array of unique Gmail/Googlemail variants. Dots and, depending on your params, plus addressing may be applied.
3) Inbox
Retrieves recent activity for a specified address, including when it was queried, response timing, how many results were found, and any available messages for verification.
- Method: GET
- URL: https://zylalabs.com/api/8382/temporary-gmail-api/14648/inbox
- Params:
- email (string, required): [email protected]
cURL:
Example JSON response:
Notes:
- email: the address this activity belongs to.
- queried_at: timestamp string for when the inbox was checked (timezone not specified by the API).
- response_time: duration string for the API’s processing time.
- count: number of messages available in this result.
- messages: array of messages; empty in this sample.
Quick-start: generate a throwaway Gmail and use it in tests
For the fastest path, call Generate Gmail, stash the email in your test context, then run your flow.
Python example (requests)
This example hits the Generate Gmail endpoint, extracts the email value, and prints it for use in downstream steps.
import os
import requests
API_KEY = os.getenv("ZYLALABS_API_KEY", "YOUR_API_KEY")
url = "https://zylalabs.com/api/8382/temporary-gmail-api/14645/generate-gmail"
params = {"domain": "random"}
headers = {"Authorization": f"Bearer {API_KEY}"}
resp = requests.get(url, params=params, headers=headers, timeout=30)
resp.raise_for_status()
data = resp.json()
email = data.get("email")
print(f"Generated temp Gmail: {email}")
# Example: pass this into your signup payload or test runner
# signup(user_email=email)
Expected shape of response is the official sample above; check data["email"] and plug that address into your automation.
Practical implementation notes
- Auth: Always send Authorization: Bearer YOUR_API_KEY.
- Timeouts: Set a client timeout (e.g., 30s) to keep test runs predictable.
- Idempotency: Generation endpoints create new variants each call; persist chosen addresses if you need repeatable runs.
- Dot and plus semantics: The Bulk GMail endpoint allows dot and plus control via its documented params. Use dot=true to get dotted variants and plus=false per the sample to avoid plus addressing.
- Inbox timestamps: queried_at is returned as a string; no timezone is specified by the API. Store it as-is or annotate with your system time for audit.
- Caching and pagination: Not specified for these endpoints. If you’re building a poller for Inbox, implement backoff and avoid unnecessary repeat calls.
- Quotas: Zyla uses subscription + quota. Monitor your call volume and check the marketplace listing for limits and current access options.
Workflow recipes
1) One-off signup testing
- Call Generate Gmail with domain=random.
- Use the returned email in your signup form.
- Optionally poll Inbox to verify that a message became available, if your workflow relies on receipt checks.
2) Load testing signups with diverse addresses
- Call Bulk GMail with dot=true&plus=false to fetch a batch of variants.
- Distribute the addresses across your workers to avoid collisions.
- Record which address maps to which test case for reproducibility.
3) Email verification QA on staging
- Provision a unique address per run (Generate Gmail).
- Trigger your system to send a verification message.
- Call Inbox for that address and store queried_at, response_time, and any messages you need for validation.
Calling the API from AI agents via MCP
If you orchestrate flows in an MCP-compatible client (e.g., Claude Code, Cursor, Windsurf), you can call Zyla APIs through the MCP gateway. Use the endpoint:
Provide your key in the query string as apikey=YOUR_API_KEY when configuring the MCP tool URL (e.g., https://mcp.zylalabs.com/mcp?apikey=YOUR_API_KEY). Then invoke the Temporary GMail API actions from your agent. Exact tool configuration depends on your client; refer to your MCP client’s docs and keep the same Authorization model and parameters shown above when the tool forwards the call.
Troubleshooting tips
- 401 or 403: Confirm you’re sending Authorization: Bearer YOUR_API_KEY and the key is active on the listing.
- Empty Inbox: It’s valid for messages to be absent; verify your upstream system actually sent email and consider retry/backoff before concluding failure.
- Unexpected count in Bulk GMail: The API returns up to 500; the exact count can vary. Read the count field and iterate over emails accordingly.
- Encoding plus addresses: When passing email to the Inbox endpoint, URL-encode characters like + and @ as shown in the sample.
Copy-ready requests
Generate one Gmail
Bulk Gmail variants (dots on, plus off)
Check inbox activity for a specific address
FAQ
What auth header do I need?
Send Authorization: Bearer YOUR_API_KEY on every request.
How many emails can I get at once?
Use the Bulk GMail endpoint to generate up to 500 unique emails in a single call, subject to your subscription quota.
Does the Inbox endpoint return full message contents?
The Inbox endpoint returns recent activity fields and available messages for verification. The exact fields you will see beyond the sample are not documented here; process the messages array if present.
Are dots and plus addressing supported?
Bulk GMail supports dot and plus rules via the dot and plus parameters. Use dot=true and plus=false as shown to control variants.
Is there a free plan?
Zyla uses a subscription + quota model. Check the marketplace listing for current access options and pricing, including the available trial.
Ready to wire this into your pipeline? Create your API key and ship your integration today: Start 7-day trial on Temporary GMail API. Explore thousands more ready-to-use services on Zyla API Hub, all with a single key.