Temp Mail

https://temp-mail-docs.awsl.uk/
Admin
Temp Mail is a free temporary email service built on CloudFlare that supports receiving and sending...
Tokens:16,724
Snippets:140
Trust Score:6
Update:10 months ago
Show doc for...
Tokens:
Raw
### Install Dependencies and Configure Environment for Frontend Deployment

Source: https://temp-mail-docs.awsl.uk/en/guide/cli/pages

Installs frontend dependencies using pnpm, copies the example environment file to a production-specific file, and instructs on modifying the VITE_API_BASE variable to point to the worker URL. This prepares the frontend for a production build and deployment.

```bash
cd frontend
pnpm install
cp .env.example .env.prod
```

--------------------------------

### Deploy Telegram Mini App via Command Line

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/telegram

These commands guide the deployment of the Telegram Mini App using the command line. It involves navigating to the frontend directory, installing dependencies, configuring environment variables, and running the deployment script. The `--project-name` flag allows for unique page creation.

```bash
cd frontend
pnpm install
cp .env.example .env.prod
# --project-name can create a separate pages for mini app, you can also share one pages, but may encounter js loading issues
pnpm run deploy:telegram --project-name=<your_project_name>
```

--------------------------------

### Local Setup for SMTP IMAP Proxy Service (Python)

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/config-smtp-proxy

This snippet details the steps to set up and run the SMTP IMAP Proxy Service locally using Python. It involves navigating to the directory, copying and modifying the environment file, creating a virtual environment, installing dependencies, and finally running the main script. Ensure 'proxy_url' and 'port' are correctly configured in the .env file.

```bash
cd smtp_proxy_server/
# Copy configuration file and modify it
# Your worker address, proxy_url=https://temp-email-api.xxx.xxx
# Your SMTP service port, port=8025
cp .env.example .env
python3 -m venv venv
./venv/bin/python3 -m pip install -r requirements.txt
./venv/bin/python3 main.py
```

--------------------------------

### Docker Setup for SMTP IMAP Proxy Service

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/config-smtp-proxy

This snippet provides instructions for setting up and running the SMTP IMAP Proxy Service using Docker Compose. It involves navigating to the directory and starting the service in detached mode. The environment variables, including 'proxy_url' and 'port', within the docker-compose.yaml file should be reviewed and modified as needed.

```bash
cd smtp_proxy_server/
docker-compose up -d
```

--------------------------------

### Example Address Allowlist Configuration

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/ai-extract

This text example demonstrates the format for configuring an address allowlist for AI email extraction. It shows how to specify exact matches, domain wildcards, user wildcards, and combinations thereof. This helps control costs and resource usage by limiting extraction to specific email addresses or domains.

```text
user@example.com
*@mydomain.com
admin*@company.com

```

--------------------------------

### Initialize Cloudflare Worker Project

Source: https://temp-mail-docs.awsl.uk/en/guide/cli/worker

Initializes a new Cloudflare Worker project by navigating to the worker directory, installing dependencies using pnpm, and copying the template configuration file.

```bash
cd worker
pnpm install
cp wrangler.toml.template wrangler.toml
```

--------------------------------

### Install mail-parser-wasm-worker (CLI)

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/mail_parser_wasm_worker

This command installs the mail-parser-wasm-worker package using pnpm within the worker directory. It's a prerequisite for enabling the WASM email parsing functionality.

```bash
cd worker
pnpm add mail-parser-wasm-worker
```

--------------------------------

### Configure ANOTHER_WORKER_LIST for Email Processing

Source: https://temp-mail-docs.awsl.uk/en/guide/worker-vars

An example TOML configuration for `ANOTHER_WORKER_LIST`, which specifies additional workers to process emails. It includes settings for binding, method, and keywords to trigger specific workers.

```toml
#ANOTHER_WORKER_LIST ="""
#[
#    {
#        "binding":"AUTH_INBOX",
#        "method":"rpcEmail",
#        "keywords":[
#            "验证码","激活码","激活链接","确认链接","验证邮箱","确认邮件","账号激活","邮件验证","账户确认","安全码","认证码","安全验证","登陆码","确认码","启用账户","激活账户","账号验证","注册确认",
#            "account","activation","verify","verification","activate","confirmation","email","code","validate","registration","login","code","expire","confirm"
#        ]
#    }
#]
#
```

--------------------------------

### Build Frontend for Pages and Deploy Backend Worker

Source: https://temp-mail-docs.awsl.uk/en/guide/cli/pages

Installs frontend dependencies, builds the frontend specifically for Cloudflare Pages (optionally disabling PWA caching for Zero Trust), and then deploys the backend worker. Assumes the worker is named 'cloudflare_temp_email' or requires modification of the 'pages/wrangler.toml' file.

```bash
cd frontend
# If you want to enable Cloudflare Zero Trust, you need to use pnpm build:pages:nopwa to disable caching
pnpm build:pages
cd ../pages
pnpm run deploy
```

--------------------------------

### Build Frontend Assets for Cloudflare Worker

Source: https://temp-mail-docs.awsl.uk/en/guide/cli/worker

Builds the frontend assets for deployment with the Cloudflare Worker. This involves navigating to the frontend directory, installing dependencies without frozen lockfiles, and running the build script for Cloudflare Pages.

```bash
cd frontend
pnpm install --no-frozen-lockfile
pnpm build:pages
```

--------------------------------

### Send Email via SMTP with Python

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/send-mail-api

Illustrates sending emails through the Temp Mail SMTP proxy using Python's smtplib. This method requires prior configuration of the SMTP proxy and a JWT Token Password for authentication. The example uses MIMEText for constructing the email content.

```python
import smtplib

from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart


with smtplib.SMTP('localhost', 8025) as smtp:
    smtp.login("jwt", "Enter your JWT token password here")
    message = MIMEMultipart()
    message['From'] = "Me <me@awsl.uk>"
    message['To'] = "Admin <admin@awsl.uk>"
    message['Subject'] = "Test Subject"
    message.attach(MIMEText("Test Content", 'html'))
    smtp.sendmail("me@awsl.uk", "admin@awsl.uk", message.as_string())
```

--------------------------------

### Webhook Data Format Example (JSON)

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/webhook

This JSON object represents the data format sent by the webhook. It includes fields like id, url, from, to, subject, raw content, parsed text, and parsed HTML of the email. The 'url' field can be constructed using the worker's FRONTEND_URL and the email's id.

```json
{
    "id": "${id}",
    "url": "${url}",
    "from": "${from}",
    "to": "${to}",
    "subject": "${subject}",
    "raw": "${raw}",
    "parsedText": "${parsedText}",
    "parsedHtml": "${parsedHtml}"
}
```

--------------------------------

### Docker Compose Configuration for SMTP IMAP Proxy Service

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/config-smtp-proxy

This YAML snippet defines the Docker Compose configuration for the SMTP IMAP Proxy Service. It specifies the service, image to use, container name, port mappings for SMTP and IMAP, and environment variables like 'proxy_url', 'port', and 'imap_port'. Users should modify these environment variables to match their specific setup.

```yaml
services:
  smtp_proxy_server:
    image: ghcr.io/dreamhunter2333/cloudflare_temp_email/smtp_proxy_server:latest
    # build:
    #   context: .
    #   dockerfile: dockerfile
    container_name: "smtp_proxy_server"
    ports:
      - "8025:8025"
      - "11143:11143"
    environment:
      - proxy_url=https://temp-email-api.xxx.xxx
      - port=8025
      - imap_port=11143
```

--------------------------------

### Redeploy Website with Google Ads via Command Line (Bash)

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/google-ads

Build and deploy your website with the updated Google Ads environment variables using pnpm. This process includes an initial build and a deployment step, which may prompt for project creation and production branch selection.

```bash
pnpm build --emptyOutDir
# For first deployment, you'll be prompted to create a project, fill in production for the production branch
pnpm run deploy
```

--------------------------------

### Initialize D1 Database with Wrangler CLI

Source: https://temp-mail-docs.awsl.uk/en/guide/cli/d1

Initializes a new D1 database and executes an SQL schema file. This involves copying a template configuration file, creating the database using 'wrangler d1 create', and then executing the schema using 'wrangler d1 execute'. The database can be viewed in the Cloudflare console after creation.

```bash
cd worker
cp wrangler.toml.template wrangler.toml
# Create D1 and execute schema.sql
wrangler d1 create dev
wrangler d1 execute dev --file=../db/schema.sql --remote
```

--------------------------------

### Build and Deploy Frontend to Cloudflare Pages

Source: https://temp-mail-docs.awsl.uk/en/guide/cli/pages

Builds the frontend project with an empty output directory and deploys it to Cloudflare Pages. This process includes an initial prompt for project creation and specifies 'production' as the branch for production deployments.

```bash
pnpm build --emptyOutDir
# The first deployment will prompt you to create a project, for production branch enter production
pnpm run deploy
```

--------------------------------

### Configure Environment Variables for Google Ads (Env)

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/google-ads

Add Google AdSense client and slot IDs to your production environment file (`.env.prod`). These variables are essential for displaying ads on your website. Refer to Google AdSense for obtaining the correct values.

```text
VITE_GOOGLE_AD_CLIENT=ca-pub-123456
VITE_GOOGLE_AD_SLOT=123456
```

--------------------------------

### Admin Console Access and Role Configuration

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/admin

To access the admin console, you must configure either ADMIN_PASSWORDS in the backend or ensure the user's role matches ADMIN_USER_ROLE. Access is granted if the user role equals ADMIN_USER_ROLE. The console can be accessed by clicking the upper-left logo 5 times or navigating to the '/admin' path after deploying the frontend.

```env
ADMIN_PASSWORDS=your_secure_password
ADMIN_USER_ROLE=ADMIN
```

--------------------------------

### Configure USER_ROLES for UI Deployment

Source: https://temp-mail-docs.awsl.uk/en/guide/worker-vars

Defines the user roles and their associated domains and prefixes when deploying through the UI. This configuration is essential for managing user permissions and access.

```json
[{"domains":["awsl.uk","dreamhunter2333.xyz"],"role":"vip","prefix":"vip"},{"domains":["awsl.uk","dreamhunter2333.xyz"],"role":"admin","prefix":""}]
```

--------------------------------

### Deploy Cloudflare Worker

Source: https://temp-mail-docs.awsl.uk/en/guide/cli/worker

Deploys the Cloudflare Worker using the `pnpm run deploy` command. The first deployment may prompt for a project name, and for the production branch, 'production' should be entered. After successful deployment, the worker URL will be provided.

```bash
pnpm run deploy
```

--------------------------------

### Configure Frontend Asset Deployment in `wrangler.toml`

Source: https://temp-mail-docs.awsl.uk/en/guide/cli/worker

Adds the `[assets]` configuration to the `wrangler.toml` file to enable the deployment of frontend assets alongside the Cloudflare Worker. It specifies the directory containing the built assets and the binding name.

```toml
[assets]
directory = "../frontend/dist/"
binding = "ASSETS"
run_worker_first = true
```

--------------------------------

### Configure USER_ROLES for CLI Deployment

Source: https://temp-mail-docs.awsl.uk/en/guide/worker-vars

Specifies the user roles and their associated domains and prefixes for deployment via the CLI, referencing the `worker/wrangler.toml.template`. This format is used in TOML configuration files.

```toml
[{ domains = ["awsl.uk", "dreamhunter2333.xyz"], role = "vip", prefix = "vip" }, { domains = ["awsl.uk", "dreamhunter2333.xyz"], role = "admin", prefix = "" }]
```

--------------------------------

### Configure Cloudflare Worker (`wrangler.toml`)

Source: https://temp-mail-docs.awsl.uk/en/guide/cli/worker

Configures the `wrangler.toml` file for a Cloudflare Worker. This includes setting the worker name, main script, compatibility date, nodejs compatibility, optional custom domain routes, frontend asset configuration, scheduled task triggers, email sending bindings, environment variables (prefix, domains, JWT secret, admin passwords, user creation/deletion flags), D1 database bindings, KV namespace bindings, rate limiters, and service bindings.

```toml
name = "cloudflare_temp_email"
main = "src/worker.ts"
compatibility_date = "2024-09-23"
compatibility_flags = [ "nodejs_compat" ]

# If you want to use a custom domain, you need to add routes configuration
# routes = [
#  { pattern = "temp-email-api.xxxxx.xyz", custom_domain = true },
# ]

# If you want to deploy a worker with frontend assets, you need to add assets configuration
# [assets]
# directory = "../frontend/dist/"
# binding = "ASSETS"
# run_worker_first = true

# If you want to use scheduled tasks to clean up emails, uncomment the following and modify the cron expression
# [triggers]
# crons = [ "0 0 * * *" ]

# Send emails through Cloudflare
# send_email = [
#    { name = "SEND_MAIL" },
# ]

[vars]
# Email name prefix, can be configured as an empty string or not configured if no prefix is needed
PREFIX = "tmp"
# All domains used for temporary email, supports multiple domains
DOMAINS = ["xxx.xxx1" , "xxx.xxx2"]
# Secret key for generating JWT, JWT is used for user login and authentication
JWT_SECRET = "xxx"

# Admin console password, if not configured, console access is not allowed
# ADMIN_PASSWORDS = ["123", "456"]

# Whether to allow users to create emails, not allowed if not configured
ENABLE_USER_CREATE_EMAIL = true
# Allow users to delete emails, not allowed if not configured
ENABLE_USER_DELETE_EMAIL = true

# D1 database name and ID can be viewed in the Cloudflare console
[[d1_databases]]
binding = "DB"
database_name = "xxx" # D1 database name
database_id = "xxx" # D1 database ID

# KV config for user registration email verification, can be skipped if user registration is not enabled or registration verification is not enabled
# [[kv_namespaces]]
# binding = "KV"
# id = "xxxx"

# Rate limit configuration for new address /api/new_address
# [[unsafe.bindings]]
# name = "RATE_LIMITER"
# type = "ratelimit"
# namespace_id = "1001"
# # 10 requests per minute
# simple = { limit = 10, period = 60 }

# Bind other workers to process emails, for example, using auth-inbox AI capabilities to parse verification codes or activation links
# [[services]]
# binding = "AUTH_INBOX"
# service = "auth-inbox"

```

--------------------------------

### Update D1 Database Schema with Wrangler CLI

Source: https://temp-mail-docs.awsl.uk/en/guide/cli/d1

Applies schema updates to an existing D1 database by executing patch SQL files. Navigate to the worker directory and use the 'wrangler d1 execute' command with the '--file' flag pointing to the specific patch file. This is used for incremental schema changes.

```bash
cd worker
wrangler d1 execute dev --file=../db/2024-01-13-patch.sql --remote
wrangler d1 execute dev --file=../db/2024-04-03-patch.sql --remote
```

--------------------------------

### Deploy Worker (CLI)

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/mail_parser_wasm_worker

This command deploys the worker after code modifications, using pnpm. It assumes you are in the worker directory. Ensure all necessary files, including WASM components, are correctly uploaded.

```bash
cd worker
pnpm run deploy
```

--------------------------------

### Send Email via SMTP

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/send-mail-api

This section details how to send emails using the SMTP protocol, requiring configuration of an SMTP proxy and authentication with a JWT token.

```APIDOC
## Send Email via SMTP

### Description
Sends emails using the standard SMTP protocol. This requires setting up an SMTP proxy and authenticating with a JWT token.

### Method
SMTP (via smtplib)

### Endpoint
`smtp://localhost:8025` (as configured in the example)

### Parameters
#### SMTP Connection
- **Host**: `localhost` (or your SMTP proxy host)
- **Port**: `8025` (or your SMTP proxy port)

#### SMTP Login
- **Username**: `jwt`
- **Password**: `Enter your JWT token password here` (This is your email login password, obtainable from the UI's password menu).

### Request Example (Python `smtplib`)
```python
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

with smtplib.SMTP('localhost', 8025) as smtp:
    smtp.login("jwt", "Enter your JWT token password here")
    message = MIMEMultipart()
    message['From'] = "Me <me@awsl.uk>"
    message['To'] = "Admin <admin@awsl.uk>"
    message['Subject'] = "Test Subject"
    message.attach(MIMEText("Test Content", 'html'))
    smtp.sendmail("me@awsl.uk", "admin@awsl.uk", message.as_string())
```

### Response
#### Success Response
- The `sendmail` method in `smtplib` typically does not return explicit success/failure status in a structured way for basic usage. Errors during sending will raise exceptions.
```

--------------------------------

### Create Cloudflare KV Cache Namespace

Source: https://temp-mail-docs.awsl.uk/en/guide/cli/worker

Creates a new KV (Key-Value) namespace named 'DEV' using the `wrangler` CLI. This is required for features like user registration email verification or Telegram Bot integration. The created namespace can be configured in `wrangler.toml`.

```bash
wrangler kv:namespace create DEV
```

--------------------------------

### Batch Create Random Email Addresses via Admin API (Python)

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/new-address-api

This Python script demonstrates how to batch create random email addresses using the admin API. It utilizes the 'requests', 'random', 'string', and 'concurrent.futures' libraries. The script defines functions to generate random names, fetch email data in parallel, and save the created email addresses and their JWTs to a file named 'email.txt'.

```python
import requests
import random
import string
from concurrent.futures import ThreadPoolExecutor, as_completed


def generate_random_name():
    # Generate 5 lowercase letters
    letters1 = ''.join(random.choices(string.ascii_lowercase, k=5))
    # Generate 1-3 digits
    numbers = ''.join(random.choices(string.digits, k=random.randint(1, 3)))
    # Generate 1-3 lowercase letters
    letters2 = ''.join(random.choices(string.ascii_lowercase, k=random.randint(1, 3)))
    # Combine into final name
    return letters1 + numbers + letters2


def fetch_email_data(name):
    try:
        res = requests.post(
            "https://<worker_domain>/admin/new_address",
            json={
                "enablePrefix": True,
                "name": name,
                "domain": "<email_domain>",
            },
            headers={
                'x-admin-auth': "<your_website_admin_password>",
                "Content-Type": "application/json"
            }
        )

        if res.status_code == 200:
            response_data = res.json()
            email = response_data.get("address", "no address")
            jwt = response_data.get("jwt", "no jwt")
            return f"{email}----{jwt}\n"
        else:
            print(f"Request failed, status code: {res.status_code}")
            return None
    except requests.RequestException as e:
        print(f"Request error: {e}")
        return None


def generate_and_save_emails(num_emails):
    with ThreadPoolExecutor(max_workers=30) as executor, open('email.txt', 'a') as file:
        futures = [executor.submit(fetch_email_data, generate_random_name()) for _ in range(num_emails)]

        for future in as_completed(futures):
            result = future.result()
            if result:
                file.write(result)


# Generate 10 emails and append to existing file
generate_and_save_emails(10)
```

--------------------------------

### Service Binding Configuration - TOML

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/another-worker-enhanced

This TOML configuration snippet shows how to set up a service binding in a Cloudflare Worker's wrangler.toml file. It binds an external worker service, named 'auth-inbox', to a variable named 'AUTH_INBOX' within the current worker, enabling RPC communication.

```toml
[[services]]
binding = "AUTH_INBOX"
service = "auth-inbox"
```

--------------------------------

### Send Email via HTTP API with Python

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/send-mail-api

Demonstrates sending emails using the Temp Mail HTTP API with Python's requests library. It shows two methods of authentication: using a JWT token in the Authorization header or within the request body. Requires the 'requests' library.

```python
import requests

send_body = {
    "from_name": "Sender Name",
    "to_name": "Recipient Name",
    "to_mail": "Recipient Address",
    "subject": "Email Subject",
    "is_html": False,  # Set whether it's HTML based on content
    "content": "<Email content: html or text>",
}

res = requests.post(
    "http://localhost:8787/api/send_mail",
    json=send_body, headers={
        "Authorization": f"Bearer {your_JWT_password}",
        # "x-custom-auth": "<your_website_password>", # If custom password is enabled
        "Content-Type": "application/json"
    }
)

# Using body authentication
send_body = {
    "token": "<your_JWT_password>",
    "from_name": "Sender Name",
    "to_name": "Recipient Name",
    "to_mail": "Recipient Address",
    "subject": "Email Subject",
    "is_html": False,  # Set whether it's HTML based on content
    "content": "<Email content: html or text>",
}
res = requests.post(
    "http://localhost:8787/external/api/send_mail",
    json=send_body, headers={
        "Content-Type": "application/json"
    }
)
```

--------------------------------

### Enable Cloudflare Email Sending (TOML)

Source: https://temp-mail-docs.awsl.uk/en/guide/config-send-mail

This TOML configuration snippet enables sending emails directly through Cloudflare's internal API for authenticated forwarding addresses. It requires the 'send_email' array to be configured in 'wrangler.toml'. Note that this method has limitations and is only supported for CLI deployments.

```toml
# Send emails through Cloudflare
send_email = [
   { name = "SEND_MAIL" },
]

```

--------------------------------

### User Mail API with Filters (Python)

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/mail-api

This Python snippet shows how to use the User Mail API with the requests library, supporting 'address' and 'keyword' filters. It requires an 'x-admin-auth' header for authentication. The URL and query parameters can be modified to target specific emails.

```python
import requests

url = "https://<your-worker-address>/user_api/mails"

querystring = {
    "limit":"20",
    "offset":"0",
    # address and keyword are optional parameters
    "address":"xxxx@awsl.uk",
    "keyword":"xxxx"
}

headers = {"x-admin-auth": "<your-Admin-password>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

--------------------------------

### Batch Create Random Email Addresses API

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/new-address-api

Generates and saves a specified number of random email addresses to a file using a thread pool for efficiency.

```APIDOC
## Batch Create Random Email Addresses API

### Description
This API allows for the batch creation of random email addresses. It utilizes a thread pool to concurrently call the `new_address` endpoint, generating unique random email addresses and saving them to a local file named `email.txt`.

### Method
POST (for individual email creation within the batch process)

### Endpoint
`https://<worker_domain>/admin/new_address` (called internally by the script)

### Parameters
#### Query Parameters
None

#### Request Body (for each individual email creation)
- **enablePrefix** (boolean) - Optional - Set to `true` to include a random prefix.
- **name** (string) - Required - A randomly generated name for the email address.
- **domain** (string) - Required - The domain for the email address (e.g., 'example.com').

### Request Example (for a single email within the batch)
```json
{
    "enablePrefix": true,
    "name": "randomname123",
    "domain": "example.com"
}
```

### Headers (for each individual email creation)
- **x-admin-auth** (string) - Required - Your website admin password.
- **Content-Type** (string) - Required - `application/json`.

### Functionality
- **`generate_random_name()`**: Creates a random string for the email's local part, combining letters and digits.
- **`fetch_email_data(name)`**: Makes a POST request to the `/admin/new_address` endpoint for a given name, handles responses, and returns formatted email and JWT.
- **`generate_and_save_emails(num_emails)`**: Manages the concurrent creation of `num_emails` using `ThreadPoolExecutor`, writing results to `email.txt`.

### Usage Example
```python
# Generate 10 emails and append to existing file
generate_and_save_emails(10)
```

### Output
Appends lines to `email.txt` in the format: `email_address----jwt`
```

--------------------------------

### Configure SMTP for Email Sending (JSON)

Source: https://temp-mail-docs.awsl.uk/en/guide/config-send-mail

This JSON object defines the SMTP configuration for sending emails. The key is the domain name, and the value contains connection details like host, port, security settings, authentication types, and credentials. This configuration is then added as a secret.

```json
{
    "awsl.uk": {
        "host": "smtp.xxx.com",
        "port": 465,
        "secure": true,
        "authType": [
            "plain",
            "login"
        ],
        "credentials": {
            "username": "username",
            "password": "password"
        }
    }
}
```

--------------------------------

### Create Single Email Address via Admin API (Python)

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/new-address-api

This Python code snippet demonstrates how to create a single new email address using the admin API. It requires the 'requests' library and takes the worker domain, desired email name, email domain, and an admin password as inputs. The output is a JSON object containing a JWT.

```python
import requests

res = requests.post(
    # Replace xxxx.xxxx with your worker domain
    "https://xxxx.xxxx/admin/new_address",
    json={
        # Enable prefix (True/False)
        "enablePrefix": True,
        "name": "<email_name>",
        "domain": "<email_domain>",
    },
    headers={
        'x-admin-auth': "<your_website_admin_password>",
        "Content-Type": "application/json"
    }
)

# Returns {"jwt": "<Jwt>"}
print(res.json())
```

--------------------------------

### View Emails using Mail API (Python)

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/mail-api

This Python code snippet demonstrates how to view emails using the Mail API with the requests library. It requires your worker address and JWT password for authentication. The limit and offset parameters can be adjusted to control the number of emails retrieved.

```python
import requests

limit = 10
offset = 0
res = requests.get(
    f"https://<your-worker-address>/api/mails?limit={limit}&offset={offset}",
    headers={
        "Authorization": f"Bearer {your-JWT-password}",
        # "x-custom-auth": "<your-website-password>", # If custom password is enabled
        "Content-Type": "application/json"
    }
)
```

--------------------------------

### Send Email via HTTP API

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/send-mail-api

This endpoint allows you to send emails programmatically using an HTTP POST request. It supports authentication via JWT token or a custom website password.

```APIDOC
## POST /api/send_mail

### Description
Sends an email using an HTTP API endpoint. Authentication is done via a JWT token provided in the Authorization header.

### Method
POST

### Endpoint
`http://localhost:8787/api/send_mail`

### Parameters
#### Headers
- **Authorization** (string) - Required - Bearer token for authentication (e.g., `Bearer YOUR_JWT_PASSWORD`).
- **Content-Type** (string) - Required - Must be `application/json`.

#### Request Body
- **from_name** (string) - Required - The name of the sender.
- **to_name** (string) - Required - The name of the recipient.
- **to_mail** (string) - Required - The email address of the recipient.
- **subject** (string) - Required - The subject of the email.
- **is_html** (boolean) - Required - Set to `true` if the content is HTML, `false` otherwise.
- **content** (string) - Required - The email content (HTML or plain text).

### Request Example
```json
{
    "from_name": "Sender Name",
    "to_name": "Recipient Name",
    "to_mail": "Recipient Address",
    "subject": "Email Subject",
    "is_html": false,
    "content": "<Email content: html or text>"
}
```

### Response
#### Success Response (200)
- The response structure for a successful email sending is not detailed in the provided text, but typically would indicate success or failure.

#### Response Example
```json
{
    "message": "Email sent successfully"
}
```

## POST /external/api/send_mail

### Description
Sends an email using an external HTTP API endpoint. Authentication is done by including the JWT token within the request body.

### Method
POST

### Endpoint
`http://localhost:8787/external/api/send_mail`

### Parameters
#### Headers
- **Content-Type** (string) - Required - Must be `application/json`.

#### Request Body
- **token** (string) - Required - Your JWT password for authentication.
- **from_name** (string) - Required - The name of the sender.
- **to_name** (string) - Required - The name of the recipient.
- **to_mail** (string) - Required - The email address of the recipient.
- **subject** (string) - Required - The subject of the email.
- **is_html** (boolean) - Required - Set to `true` if the content is HTML, `false` otherwise.
- **content** (string) - Required - The email content (HTML or plain text).

### Request Example
```json
{
    "token": "YOUR_JWT_PASSWORD",
    "from_name": "Sender Name",
    "to_name": "Recipient Name",
    "to_mail": "Recipient Address",
    "subject": "Email Subject",
    "is_html": false,
    "content": "<Email content: html or text>"
}
```

### Response
#### Success Response (200)
- The response structure for a successful email sending is not detailed in the provided text, but typically would indicate success or failure.

#### Response Example
```json
{
    "message": "Email sent successfully"
}
```
```

--------------------------------

### Admin Mail API with Filters (Python)

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/mail-api

This Python code uses the requests library to interact with the Admin Mail API. It allows filtering emails by 'address' and 'keyword'. Authentication is handled via an 'x-admin-auth' header with your Admin password. The URL and query parameters should be configured according to your needs.

```python
import requests

url = "https://<your-worker-address>/admin/mails"

querystring = {
    "limit":"20",
    "offset":"0",
    # address and keyword are optional parameters
    "address":"xxxx@awsl.uk",
    "keyword":"xxxx"
}

headers = {"x-admin-auth": "<your-Admin-password>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

--------------------------------

### Worker to Extend WorkerEntrypoint - TypeScript

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/another-worker-enhanced

This TypeScript code defines a Cloudflare Worker that extends WorkerEntrypoint, demonstrating how to handle incoming requests and email messages, and expose an RPC interface for other workers. It shows how to access environment variables and context within the WorkerEntrypoint style.

```typescript
import { WorkerEntrypoint } from "cloudflare:workers";

interface Env {
    DB: D1Database;
    // ...
}

export default class extends WorkerEntrypoint<Env> {
    async fetch(request: Request): Promise<Response> {
        console.log("Original fetch interface parameter is request,env,ctx");
        console.log("After modifying to WorkerEntrypoint style, there's only one parameter request, getting environment variables and context has slight changes");
        // Environment variable and context changes see:
        // https://developers.cloudflare.com/workers/runtime-apis/bindings/service-bindings/rpc/#bindings-env
        // https://developers.cloudflare.com/workers/runtime-apis/bindings/service-bindings/rpc/#lifecycle-methods-ctx
        const env: Env = this.env;
        const ctx: ExecutionContext = this.ctx;
        console.log("Subsequent logic remains unchanged");
        return new Response('ok', { status: 200 });
    }

    // Main functionality
    async email(message: ForwardableEmailMessage): Promise<void> {
        console.log("Original fetch interface parameter is message,env,ctx");
        console.log("After modifying to WorkerEntrypoint style, there's only one parameter message, getting environment variables and context is the same as fetch method");
        const env: Env = this.env;
        const ctx: ExecutionContext = this.ctx;
        console.log("After receiving email routing request, subsequent logic remains unchanged");
    }

    // Expose RPC interface to handle email requests from other workers
    async rpcEmail(requestBody: string): Promise<void> {
        console.log(`Received request from another worker (temporary email service cloudflare_temp_email), request body: ${requestBody}`);
        // requestBody is in JSON format, sent by temporary email service, format as follows
        // type RPCEmailMessage = {
        //     from: string | undefined | null,
        //     to: string | undefined | null,
        //     rawEmail: string | undefined | null,
        //     headers: Map<string, string>,
        // }
        // ... todo ...
    }
}
```

--------------------------------

### Enable WASM Email Parsing (TypeScript)

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/mail_parser_wasm_worker

This TypeScript code snippet demonstrates how to enable email parsing using the mail-parser-wasm-worker. It includes a fallback to PostalMime if the WASM worker fails. The function `commonParseMail` takes raw email content and returns parsed email details.

```typescript
export const commonParseMail = async (raw_mail: string | undefined | null): Promise<{
    sender: string,
    subject: string,
    text: string,
    html: string
} | undefined> => {
    if (!raw_mail) {
        return undefined;
    }
    // Uncomment this code to use mail-parser-wasm-worker to parse emails start
    // TODO: WASM parse email
    try {
        const { parse_message_wrapper } = await import('mail-parser-wasm-worker');

        const parsedEmail = parse_message_wrapper(raw_mail);
        return {
            sender: parsedEmail.sender || "",
            subject: parsedEmail.subject || "",
            text: parsedEmail.text || "",
            headers: parsedEmail.headers || [],
            html: parsedEmail.body_html || "",
        };
    } catch (e) {
        console.error("Failed use mail-parser-wasm-worker to parse email", e);
    }
    // Uncomment this code to use mail-parser-wasm-worker to parse emails end
    try {
        const { default: PostalMime } = await import('postal-mime');
        const parsedEmail = await PostalMime.parse(raw_mail);
        return {
            sender: parsedEmail.from ? `${parsedEmail.from.name} <${parsedEmail.from.address}>` : "",
            subject: parsedEmail.subject || "",
            text: parsedEmail.text || "",
            html: parsedEmail.html || "",
        };
    }
    catch (e) {
        console.error("Failed use PostalMime to parse email", e);
    }
    return undefined;
}
```

--------------------------------

### Add Resend API Token Secret (Bash)

Source: https://temp-mail-docs.awsl.uk/en/guide/config-send-mail

This command adds the Resend API token as a secret to your worker environment. It's crucial for authenticating with the Resend service. Ensure you are in the worker directory before execution. For multiple domains, create secrets named RESEND_TOKEN_DOMAIN_NAME.

```bash
# Switch to worker directory
cd worker
wrangler secret put RESEND_TOKEN
```

```bash
wrangler secret put RESEND_TOKEN_XXX_COM
wrangler secret put RESEND_TOKEN_DREAMHUNTER2333_XYZ
```

--------------------------------

### Configure S3 Secrets with Wrangler CLI

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/s3-attachment

This snippet shows how to add S3 credentials as secrets to a Cloudflare worker using the `wrangler secret put` command. It assumes you have already obtained the S3_ENDPOINT, Access Key ID, Secret Access Key, and bucket name. These secrets are crucial for the application to interact with your S3 storage.

```bash
cd worker
pnpm wrangler secret put S3_ENDPOINT
pnpm wrangler secret put S3_ACCESS_KEY_ID
pnpm wrangler secret put S3_SECRET_ACCESS_KEY
# Note: Replace bucket with your bucket name
pnpm wrangler secret put S3_BUCKET
```

--------------------------------

### Disable Admin Password Check for Private Access

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/admin

For websites intended for private access only, you can disable the administrative password check entirely. This is achieved by setting the environment variable DISABLE_ADMIN_PASSWORD_CHECK to true. This setting simplifies access for internal users without compromising security on public-facing platforms.

```env
DISABLE_ADMIN_PASSWORD_CHECK=true
```

--------------------------------

### Configure Cloudflare Workers AI Binding in wrangler.toml

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/ai-extract

This TOML snippet shows how to configure the Workers AI binding in the wrangler.toml file, which is necessary for the AI email recognition feature to function. The binding is named 'AI'.

```toml
[ai]
binding = "AI"

```

--------------------------------

### POST /admin/new_address

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/new-address-api

Creates a new email address using the Admin API. You can specify a custom name and domain, or enable a random prefix.

```APIDOC
## POST /admin/new_address

### Description
Creates a new email address via the Admin API. This endpoint allows for the creation of specific email addresses by providing a name and domain, or for the generation of addresses with a prefixed name.

### Method
POST

### Endpoint
`https://<worker_domain>/admin/new_address`

### Parameters
#### Query Parameters
None

#### Request Body
- **enablePrefix** (boolean) - Optional - If true, a random prefix will be added to the email name.
- **name** (string) - Required - The desired local part of the email address (before the '@').
- **domain** (string) - Required - The domain for the email address (e.g., 'example.com').

### Request Example
```json
{
    "enablePrefix": true,
    "name": "mycustomname",
    "domain": "example.com"
}
```

### Headers
- **x-admin-auth** (string) - Required - Your website admin password for authentication.
- **Content-Type** (string) - Required - Should be set to `application/json`.

### Response
#### Success Response (200)
- **jwt** (string) - A JSON Web Token for further operations.
- **address** (string) - The newly created email address.

#### Response Example
```json
{
    "jwt": "<Jwt>",
    "address": "mycustomname@example.com"
}
```
```

--------------------------------

### Viewing Emails via Mail API

Source: https://temp-mail-docs.awsl.uk/en/guide/feature/mail-api

This endpoint allows users to view emails using a JWT password for authentication. It supports limit and offset for pagination.

```APIDOC
## GET /api/mails

### Description
Retrieves a list of emails with pagination support.

### Method
GET

### Endpoint
`/api/mails`

### Parameters
#### Query Parameters
- **limit** (integer) - Optional - The maximum number of emails to return.
- **offset** (integer) - Optional - The number of emails to skip before returning results.

#### Request Body
None

### Request Example
```python
import requests

limit = 10
offset = 0
res = requests.get(
    f"https://<your-worker-address>/api/mails?limit={limit}&offset={offset}",
    headers={
        "Authorization": f"Bearer {your-JWT-password}",
        # "x-custom-auth": "<your-website-password>", # If custom password is enabled
        "Content-Type": "application/json"
    }
)
```

### Response
#### Success Response (200)
- **emails** (array) - A list of email objects.
  - **id** (string) - The unique identifier for the email.
  - **subject** (string) - The subject of the email.
  - **from** (string) - The sender's email address.
  - **to** (string) - The recipient's email address.
  - **received_at** (string) - The timestamp when the email was received.

#### Response Example
```json
{
  "emails": [
    {
      "id": "email_id_1",
      "subject": "Meeting Reminder",
      "from": "sender@example.com",
      "to": "recipient@example.com",
      "received_at": "2023-10-27T10:00:00Z"
    }
  ]
}
```
```
Tokens:
Raw