Guerrilla Mail

Overview

Guerrilla Mail is a web-based service that provides users with temporary, disposable email addresses. Established in 2006, its primary function is to offer a mechanism for receiving emails without exposing a personal or primary email account. This approach is particularly useful in scenarios requiring email verification for online services, forum registrations, or accessing content that demands an email sign-up, where the user prefers to maintain anonymity or avoid potential spam.

The service operates by assigning a random email address to the user, valid for a limited duration, typically an hour, though it can be extended. Users can send and receive emails through this temporary address directly from the Guerrilla Mail website interface. Received emails are displayed in a simple inbox, and the service also includes a feature to compose and send emails from the temporary address, albeit with certain limitations, such as a maximum attachment size of 150 MB. This functionality allows for two-way communication without revealing the sender's actual email identity.

Guerrilla Mail is designed for individuals and developers who prioritize privacy and wish to minimize their digital footprint. It is commonly utilized by developers for testing email-dependent features during application development, such as user registration flows, password reset mechanisms, or notification systems. By using a disposable email, developers can quickly verify email delivery and content without creating numerous test accounts on their primary email providers. The service's straightforward web interface makes it accessible for non-technical users seeking a quick solution for temporary email needs.

While the primary interface is web-based, Guerrilla Mail's underlying API allows for programmatic interaction, although it is not officially documented for public use. Community-contributed wrappers and libraries exist for various programming languages, enabling developers to integrate temporary email generation and retrieval into their automated testing scripts or applications. This unofficial API access extends its utility beyond manual web usage, facilitating more complex automation tasks where temporary email addresses are required on demand.

Key features

• Disposable email addresses: Generates temporary email addresses that expire after a set period, typically 60 minutes, with an option to extend the lifespan.
• Anonymous inbox: Provides a web-based inbox to receive emails sent to the temporary address, displaying sender, subject, and content.
• Email sending capability: Allows users to compose and send emails from the temporary address, supporting basic text and attachments up to 150 MB.
• Alias functionality: Users can create custom aliases for their temporary addresses, offering a degree of personalization while maintaining anonymity.
• Spam protection: Helps users avoid unsolicited emails and marketing communications by providing an alternative to their primary email address for sign-ups.
• No registration required: The service can be used instantly without creating an account or providing personal information.
• API access (unofficial): Though not officially documented, an underlying API allows for programmatic generation and retrieval of temporary emails, primarily via community-developed clients.

Pricing

As of May 28, 2026, Guerrilla Mail operates under a free-to-use model. The service does not offer tiered plans or premium subscriptions. Its operations are supported primarily through advertising displayed on its website.

For the most current information regarding service availability and any potential changes to its free model, users can refer to the Guerrilla Mail homepage.

Common integrations

Guerrilla Mail's primary integration method for developers is through its unofficial API, which community projects have wrapped into various programming languages. These integrations are typically used for automated testing and development workflows.

• Python libraries: Community-developed Python packages allow for programmatic interaction with Guerrilla Mail, enabling scripts to generate temporary addresses and fetch emails for automated testing frameworks.
• JavaScript/Node.js modules: Similar to Python, Node.js modules exist that provide an interface to Guerrilla Mail's API, useful for testing email functionalities in web applications or backend services.
• Testing frameworks: Developers often integrate Guerrilla Mail into continuous integration (CI) pipelines or local testing environments to validate email-dependent features like user sign-up, password resets, and notification systems without manual intervention.
• Browser extensions: While not a direct API integration, browser extensions for Guerrilla Mail allow for quick generation and access to temporary inboxes directly within the browser, streamlining manual testing or privacy-focused browsing.

Alternatives

• 10 Minute Mail: Offers temporary email addresses that are valid for exactly ten minutes, with options to extend the duration.
• Temp Mail: Provides disposable email addresses for various purposes, including avoiding spam and maintaining anonymity, with a user-friendly interface.
• Mailinator: A public, open-to-all email system for testing and disposable email needs, known for its ability to receive emails at any address without prior setup.
• Email aliases: Many standard email providers (like Gmail or Outlook) allow users to create aliases or use plus addressing (e.g., [email protected]) to filter emails, serving as a more persistent, though less anonymous, alternative for managing specific registrations.

Getting started

While Guerrilla Mail primarily offers a web interface, developers can interact with it programmatically using community-contributed wrappers. Below is a conceptual example using a hypothetical Python wrapper to illustrate how one might generate a temporary email and check its inbox. This example assumes a Python library named guerrillamail_api exists and is installed.

import time
# This is a hypothetical library. Actual community libraries may vary.
# Example: pip install python-guerrillamail
from guerrillamail_api import GuerrillaMailSession

def get_temp_email_and_check_inbox():
    session = GuerrillaMailSession()
    email_address = session.get_email_address()
    print(f"Generated temporary email: {email_address}")

    print("Waiting for emails... (checking every 5 seconds for up to 60 seconds)")
    start_time = time.time()
    while time.time() - start_time < 60:
        emails = session.check_inbox()
        if emails:
            print(f"Received {len(emails)} email(s):")
            for email in emails:
                print(f"  From: {email['from_addr']}")
                print(f"  Subject: {email['subject']}")
                print(f"  Body: {email['body']}")
            return
        time.sleep(5)
    print("No emails received within the timeout period.")

if __name__ == "__main__":
    get_temp_email_and_check_inbox()

This Python snippet demonstrates the typical workflow: initializing a session, retrieving a temporary email address, and then polling the inbox for incoming messages. Developers would integrate such logic into their automated tests or scripts to simulate user registration and email verification processes.