Create disposable email addresses, receive incoming emails, and automate your workflows with just two simple API requests. Completely free.
We're excited to announce that
TempFastMail is now API-ready!
That's right! You can now integrate our temporary email service directly into your applications, websites, automation scripts, and testing environments using our simple REST API.
And here's the best part: The TempFastMail API is 100% FREE to use.
No expensive API subscriptions. No complicated integrations. Just a straightforward way to generate temporary email addresses and retrieve incoming messages programmatically.
Whether you're a developer building an application, a QA engineer testing email functionality, or someone automating workflows, our API makes working with temporary email addresses easier than ever.
What Is the TempFastMail API?
The TempFastMail API is a RESTful interface that allows developers to create temporary email inboxes and retrieve received emails directly from their own software.
Instead of manually visiting a temporary email website, generating an address, and checking for messages, you can now automate the entire process.
With the TempFastMail API, you can:
- Generate temporary email addresses instantly with a single API request.
- Retrieve incoming emails programmatically using a unique inbox identifier.
- Integrate disposable email functionality into your applications and services.
- Automate email-related testing without managing real email accounts.
- Build custom email workflows using a simple JSON-based API.
- Use everything completely free, without paying for API access.
We've designed the API with simplicity in mind. You don't need a complicated setup to get started.
In fact, you only need two endpoints to start working with temporary emails.
How Does the TempFastMail API Work?
Our API follows a simple two-step process:
Step 1: Create a temporary email inbox using a POST request.
Step 2: Retrieve incoming emails using a GET request with the inbox's unique identifier.
That's it!
Let's explore both endpoints.
Step 1: Create a Temporary Email Address
To generate a new disposable email address, send a POST request to the following endpoint:
Endpoint:
POST https://tempfastmail.com/api/email-box
Example using cURL:
curl -X POST https://tempfastmail.com/api/email-box
Example API response:
{
"email": "[email protected]",
"uuid": "d705c9b8-9845-4d39-92c7-d048b44fcf3e"
}The response contains two important fields:
- email: Your newly generated temporary email address, ready to receive messages.
- uuid: A unique identifier associated with your temporary inbox. You'll use this identifier to retrieve incoming emails.
You can immediately use the generated email address in your application or testing environment.
There is no need to manually create an inbox or choose an email address.
Step 2: Retrieve Incoming Emails
Once you have generated a temporary email address, you can retrieve its incoming messages using the UUID returned in the previous step.
Endpoint:
GET https://tempfastmail.com/api/email-box/{uuid}/emails
Replace {uuid} with the unique identifier of your temporary inbox.
Example using cURL:
curl -X GET \
"https://tempfastmail.com/api/email-box/d705c9b8-9845-4d39-92c7-d048b44fcf3e/emails"
The API returns an array of emails received by that inbox.
You can process the returned data directly in your application, making it easy to build automated workflows around incoming email messages.
For example, your application can periodically check the endpoint to determine whether a new message has arrived.
No manual inbox refreshing. No switching between browser tabs. Everything can be handled through code.
JavaScript Example: Integrate TempFastMail Into Your Application
If you're working with JavaScript or Node.js, integrating the TempFastMail API is straightforward.
Here's a basic example demonstrating how to generate a temporary email address and retrieve its messages.
const API_URL = "https://tempfastmail.com/api";
// Step 1: Generate a temporary email inbox
async function createTempEmail() {
const response = await fetch(`${API_URL}/email-box`, {
method: "POST"
});
if (!response.ok) {
throw new Error("Failed to create email inbox");
}
return await response.json();
}
// Step 2: Retrieve incoming emails
async function getEmails(uuid) {
const response = await fetch(
`${API_URL}/email-box/${uuid}/emails`
);
if (!response.ok) {
throw new Error("Failed to retrieve emails");
}
return await response.json();
}
// Example usage
async function main() {
const inbox = await createTempEmail();
console.log("Temporary email:", inbox.email);
console.log("Inbox UUID:", inbox.uuid);
const emails = await getEmails(inbox.uuid);
console.log("Received emails:", emails);
}
main().catch(console.error);With just a few lines of code, your application can generate disposable inboxes and access their received messages.
You can adapt this example for your own projects, whether you're building automated tests, backend services, or developer tools.
Python Example: Generate a Temporary Email in Seconds
Prefer Python? No problem!
Here's an example using the popular requests library.
import requests
BASE_URL = "https://tempfastmail.com/api"
# Step 1: Generate a temporary email
response = requests.post(
f"{BASE_URL}/email-box",
timeout=15
)
response.raise_for_status()
inbox = response.json()
email = inbox["email"]
uuid = inbox["uuid"]
print("Temporary email:", email)
print("UUID:", uuid)
# Step 2: Retrieve received emails
response = requests.get(
f"{BASE_URL}/email-box/{uuid}/emails",
timeout=15
)
response.raise_for_status()
emails = response.json()
print("Received emails:", emails)That's all you need to start using temporary email addresses inside your Python applications.
The same approach works with PHP, Java, Go, C#, Ruby, and practically any programming language capable of making HTTP requests.
Why Use a Temporary Email API?
Temporary email addresses are useful for far more than simply avoiding unwanted emails.
When combined with an API, they become a powerful tool for developers and automated systems.
Here are some practical use cases.
1. Automated Application Testing
Testing registration forms, email confirmations, and notifications can be frustrating when you need to create and manage multiple email accounts.
With the TempFastMail API, you can generate a new temporary inbox for each test.
For example:
- Generate a temporary email address through the API.
- Register a test user in your application.
- Trigger an email verification message.
- Retrieve incoming emails through the API.
- Validate that the expected email was delivered.
This is particularly useful for automated integration tests and end-to-end testing.
2. QA and Software Development
Quality assurance teams often need to verify that applications send emails correctly.
Instead of relying on personal email accounts or maintaining dedicated test inboxes, QA engineers can dynamically generate disposable addresses.
This helps keep testing environments organized and reduces the effort needed to prepare test accounts.
3. CI/CD Pipelines
Continuous integration and continuous deployment pipelines frequently run automated tests that involve email functionality.
By integrating TempFastMail, you can create fresh temporary inboxes during testing and retrieve messages programmatically.
This can be particularly useful for testing applications that send welcome emails, verification messages, or account notifications.
4. Email Notification Testing
Building a system that sends transactional emails?
You can use TempFastMail to test whether your application's outgoing notifications arrive at the intended inbox.
This can help developers validate email delivery during development without cluttering personal or business inboxes.
5. Custom Automation and Developer Tools
Developers can also integrate TempFastMail into their own internal tools and automation workflows.
For example, you might build:
- An automated email testing dashboard.
- A custom QA testing platform.
- A development tool that creates disposable test identities.
- An automated workflow that processes incoming test emails.
- A testing utility for applications that send transactional notifications.
Because the API returns JSON, connecting it to existing systems is straightforward.
The Best Part: The TempFastMail API Is Completely FREE!
Let's talk about pricing.
Many developers are familiar with API services that introduce paid plans, usage-based billing, or additional costs as projects grow.
At TempFastMail, we're taking a simpler approach: Our temporary email API is completely free to use.
You don't need to purchase an API subscription to access the two endpoints described above.
Our goal is to make temporary email functionality accessible to developers, independent builders, students, QA teams, and anyone who needs programmatic access to disposable inboxes.
Whether you're experimenting with a small personal project or integrating temporary email functionality into your development workflow, you can get started without paying for API access.
We believe useful developer tools should be easy to access, easy to integrate, and affordable.
And free is about as affordable as it gets!
What Makes TempFastMail Different?
There are various temporary email services available online, but not every solution provides the same integration experience.
TempFastMail focuses on keeping the process simple.
Two API endpoints are enough to get started.
You create an inbox, receive an email address and UUID, and then use that UUID to retrieve messages.
There's no need to understand a complicated API architecture just to create a disposable email inbox.
Here's what makes our approach especially convenient:
Simple integration: Just make a POST request to generate an inbox and a GET request to retrieve its emails.
Developer-friendly responses: Work with JSON data that can be consumed by modern programming languages and frameworks.
Easy automation: Generate inboxes dynamically and integrate incoming email retrieval into your existing application logic.
No manual interaction required: You can build your entire workflow around API calls rather than visiting a website to manage inboxes.
Completely free API access: Take advantage of disposable email functionality without an API subscription.
Our focus is on delivering an accessible, straightforward temporary email API that developers can begin using immediately.
TempFastMail API Reference
Here's a quick overview of the available API endpoints.
Create a Temporary Inbox
Method: POST
URL: https://tempfastmail.com/api/email-box
Response example:
{
"email": "[email protected]",
"uuid": "d705c9b8-9845-4d39-92c7-d048b44fcf3e"
}Get Emails From an Inbox
Method: GET
URL: https://tempfastmail.com/api/email-box/{uuid}/emails
Response: JSON array containing emails received by the specified inbox.
That's everything you need for a basic TempFastMail API integration.
Frequently Asked Questions
Is the TempFastMail API free?
Yes! The TempFastMail API is completely free to use. You can create temporary email inboxes and retrieve incoming messages without purchasing API access.
Can I create temporary email addresses programmatically?
Absolutely. Simply send a POST request to https://tempfastmail.com/api/email-box, and you'll receive a generated email address and its unique UUID.
How can I read emails using the API?
Send a GET request to https://tempfastmail.com/api/email-box/{uuid}/emails using the UUID returned when your inbox was created.
The endpoint returns the emails associated with that temporary inbox.
Which programming languages are supported?
You can use the TempFastMail API with any programming language that supports HTTP requests, including JavaScript, Python, PHP, Java, Go, and C#.
Can I use the API for automated testing?
Yes! The API is particularly useful for testing registration flows, verification emails, notifications, and other email-related functionality in applications you develop or are authorized to test.
Can I integrate TempFastMail into my own service?
Yes. That's exactly why we've introduced API access.
You can integrate temporary email generation and inbox retrieval directly into your own services, applications, and development tools.
Start Using the Free TempFastMail API Today!
We're excited to make TempFastMail more accessible to developers around the world.
With our new API functionality, you no longer need to generate temporary email addresses manually. Everything can now be handled directly from your application using simple HTTP requests.
Create an inbox. Get an email address. Retrieve incoming messages. Automate your workflow.
All with just two API endpoints.
And remember: The TempFastMail API is completely FREE!
Ready to get started?
Visit
TempFastMail.com and start integrating temporary email functionality into your projects today.
TempFastMail - Temporary Email Made Simple. Now Available via API. For Free.