# Temp Email API — Disposable Inboxes & Messages (`apivault_labs/temp-email`) Actor

Create or inspect supported disposable inboxes; return received messages and verification fields when available. Bulk export: JSON, CSV, Excel and API. PPE: $10/1K inbox results; start fee extra; mode rates differ.

- **URL**: https://apify.com/apivault_labs/temp-email.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** Developer tools, Automation, AI
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 80 total users, 6 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 message receiveds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 📧 Temp Email — Disposable Inbox, OTP & Verification Catcher

Spin up a **disposable email inbox** in seconds and read its incoming messages — **one-time codes (OTP), sign-up confirmations and verification links** — on demand. Perfect for **QA, test automation, sign-up flows, scraping pipelines and bots** that need a throwaway mailbox.

No separate mailbox-service registration is required for the standard create flow; an Apify account is required to run the Actor. Create an inbox instantly, then read it on demand with built-in **OTP/verification-code extraction**.

***

### 📮 Available domains

Just pick a domain from the dropdown when you create the address:

- **Auto** — the fastest, most reliable random address (recommended).

- **Branded custom domains:** `@swagpapa.com` · `@rulersonline.com` · `@besttempmail.com` · `@deepmails.org` · `@embassybase.com` · `@justdefinition.com` · `@gongjua.com` · `@123mails.org`

- **Gmail aliases:** dot trick (`a.b.c@gmail.com`), plus trick (`abc+tag@gmail.com`), Googlemail (`a.bc@googlemail.com`).

> **Reading:** Auto inboxes are read with their key (token). Branded and Gmail inboxes can be read with **just the address** — leave the key empty.

***

### ✨ Highlights

- 📨 **Create a throwaway inbox** instantly — pick any domain, get the address + credentials in a source-dependent time.

- 📥 **Read on demand** — when you expect a message, run `read` on the inbox; it polls until the mail lands (great for catching a verification email after a sign-up).

- 🔑 **OTP & link extraction** — pulls likely one-time codes and verification/confirmation links out of the message body.

- 🎯 **Wait for the right email** — filter by sender, subject or keyword and keep polling until the email you actually want arrives (ignore inbox noise and old mail).

- 📎 **Attachments** — see attachment metadata (filename, type, size, download URL) on each message.

- 📦 **Bulk create** — spin up many inboxes in a single run for load and parallel QA testing.

- 🛡️ **Reliable by default** — create retries automatically and falls back to the fast Auto pool if a branded inbox is unavailable.

- 🏷️ **Branded domains & Gmail aliases** — varied addresses, or a fast random one.

- 🔑 **Read by address** — branded/Gmail inboxes open with just the email (no key to keep).

- 🔁 **Re-readable** — the create result carries the inbox credentials so you can read the same inbox while the provider retains it.

- 🆓 **Keyless** — no key, no signup, no proxy.

***

### 🧠 How it works

Two simple, separate steps:

| Action | What it does |

|--------|--------------|

| `create` *(default)* | Makes a new inbox and returns its **address + credentials instantly** (source-dependent time). No waiting. |

| `read` | Checks an existing inbox for messages. Pass the `address` + credentials from a create run; it polls up to `waitTimeout` for new mail. |

Typical automation flow:

1. Run **create** → get the `address` (+ `token`/`password` or `code`).

2. Use the address to sign up somewhere / trigger a mail.

3. Run **read** with that address + credentials → get the message and the extracted `firstCode`.

***

### 📥 Input

| Field | Type | Default | Description |

|-------|------|---------|-------------|

| `domain` | string | `auto` | Pick the address domain: `auto`, a branded domain, or a Gmail alias. |

| `action` | string | `create` | `create` (new inbox, instant) or `read` (check an existing inbox). |

| `username` | string | — | Local part for the **Auto** domain (random if empty). |

| `count` | integer | `1` | `create` only: number of inboxes to create in one run (1-25). |

| `allowFallback` | boolean | `true` | `create` only: fall back to a reliable Auto inbox if a branded/Gmail inbox fails. |

| `address` | string | — | Inbox address (for `action=read`). |

| `inboxes` | array | — | `read` only: check several inboxes in one run, e.g. `[{"address":"a@x.com","key":"..."}]`. |

| `key` / `password` | string | — | Credentials for an **Auto** inbox (for `read`). |

| `key` | string | — | Pass a provider token/code through the schema-supported key input when needed. |

| `waitTimeout` | integer | `0` | `read` only: 0 = check once and return instantly (fast). Set >0 to wait for mail. |

| `pollInterval` | integer | `6` | `read` only: seconds between inbox checks. |

| `matchFrom` | string | — | `read` only: keep waiting until an email from a sender containing this text arrives. |

| `matchSubject` | string | — | `read` only: only return emails whose subject contains this text. |

| `matchKeyword` | string | — | `read` only: only return emails containing this text anywhere (subject/body). |

| `onlyUnseen` | boolean | `false` | `read` only: skip messages already marked as seen. |

| `waitForNew` | boolean | `false` | `read` only: ignore mail already in the inbox when the run starts. |

| `latestOnly` | boolean | `false` | `read` only: return just the newest matching message. |

| `maxMessages` | integer | `0` | `read` only: cap how many matching emails to return (0 = no limit). |

| `extractCodes` | boolean | `true` | Extract OTP codes and verification links. |

| `includeBody` | boolean | `true` | Include full text/HTML body per message. |

| `codeMinLength` / `codeMaxLength` | integer | `4` / `8` | Length range for OTP code detection. |

| `codeRegex` | string | — | Advanced: custom regex to extract the code yourself. |

| `includeRaw` | boolean | `false` | Also return raw EML + parsed headers and SPF/DKIM/DMARC (Auto inboxes only). |

#### Example: create an inbox (instant)

```json

{

  "action": "create",

  "domain": "auto"

}

```

#### Example: create several inboxes at once

```json

{

  "action": "create",

  "domain": "auto",

  "count": 10

}

```

#### Example: branded address, then read it later

```json

{ "action": "create", "domain": "swagpapa.com" }

```

```json

{ "action": "read", "address": "abc@swagpapa.com" }

```

> Add `"waitTimeout": 60` to a read if you want it to keep waiting for an incoming mail instead of returning instantly.

#### Example: wait for the verification email from a specific sender

```json

{

  "action": "read",

  "address": "abc@swagpapa.com",

  "matchFrom": "no-reply@service.com",

  "waitForNew": true,

  "latestOnly": true,

  "waitTimeout": 90

}

```

> This keeps polling (ignoring anything already in the inbox) until a fresh email from `service.com` lands, then returns just that one message with its extracted `firstCode`.

#### Example: check several inboxes at once

```json

{

  "action": "read",

  "inboxes": [

    { "address": "a@swagpapa.com" },

    { "address": "u4f9k2@example.net", "key": "eyJ0eXAiOiJKV1Q..." }

  ]

}

```

> Takes one snapshot per inbox. Branded/Gmail addresses open with just the address; Auto addresses need their `key` (token).

***

### 📤 Output

**create** → one item with the new inbox address and its credentials:

```json

{

  "success": true,

  "address": "u4f9k2@example-domain.com",

  "token": "eyJ0eXAiOiJKV1Q...",

  "password": "…",

  "messageCount": 0

}

```

**read** → **one dataset item per email** (so a 3-message inbox = 3 results). Each item is a full message:

```json

{

  "success": true,

  "address": "u4f9k2@example-domain.com",

  "messageIndex": 1,

  "messageCount": 2,

  "id": "…",

  "from": "no-reply@service.com",

  "fromName": "Service",

  "subject": "Your verification code",

  "text": "…",

  "html": "…",

  "otpCodes": ["424864"],

  "verificationLinks": ["https://service.com/verify?token=…"],

  "firstCode": "424864",

  "token": "eyJ0eXAiOiJKV1Q..."

}

```

If the inbox is empty, **read** returns a single summary item with `messageCount: 0` and the inbox credentials so you can read again later.

| Field | Description |

|-------|-------------|

| `address` | The disposable inbox address. |

| `token` / `password` or `code` | Credentials to re-read this inbox later. |

| `messageIndex` / `messageCount` | Position of this email and the total found this read. |

| `from` / `fromName` / `subject` | Sender and subject of the email. |

| `text` / `html` | Full message body. |

| `otpCodes[]` / `verificationLinks[]` | Extracted one-time codes and verification links. |

| `verificationTokens[]` | Token-like values pulled from verification link query params (e.g. magic-link / passwordless tokens). |

| `firstCode` | The first extracted OTP code of this message (handy shortcut). |

| `hasAttachments` / `attachments[]` | Whether the email has attachments, and their metadata (filename, contentType, size, downloadUrl). |

| `raw` / `headers` / `authResults` | Raw EML source, parsed headers and the Authentication-Results line (when `includeRaw` is on, Auto inboxes). |

| `spf` / `dkim` / `dmarc` | Authentication verdicts parsed from the headers (`pass` / `fail`), when available. |

***

### 💡 Use cases

- **Automated sign-up / account testing** — catch the confirmation email and code.

- **QA & end-to-end tests** — verify your product's transactional emails.

- **Scraping & bots** — register throwaway accounts that need email verification.

- **OTP capture** — pull the one-time code straight into your workflow.

### ⚙️ Notes & limits

- Billed per **inbox created** and per **message retrieved** — `create` = one charge for the new inbox; `read` = one charge per email delivered. **An empty read has no message-received event**, but startup and platform resources still apply.

- **create** is instant; **read** checks once by default (`waitTimeout` 0) — set `waitTimeout` to keep waiting for mail to arrive.

- Disposable inboxes are short-lived by nature; read them promptly.

- Branded inboxes are rate-limited, so `read` uses a safe minimum poll interval automatically.

***

Built and maintained by **Apivault** — reliable data Actors, fair pricing.

***

### ⚖️ Legal, Compliance & Acceptable Use

**Please read this section carefully. By running this Actor you accept these terms.**

> **Bottom line:** this is a neutral, general-purpose software tool. It processes disposable test-inbox data that you are authorized to access. **You — the user —
> decide what to search for and how to use the results, so you alone are
> responsible and liable for that use.** The developer/operator of this Actor
> merely provides the tool and does not control, endorse, or take responsibility
> for what you do with it.

**1. Authorized test inboxes only.** Create a test inbox or use credentials for one you are authorized to read. Do not use this tool to access another person’s mailbox.

**2. You are the responsible party (data controller).** For every run you start,
**you** act as the data controller and are solely responsible for using the
output lawfully. This includes having a valid **lawful basis** (for business/B2B
use this is typically *legitimate interest*), honoring **data-subject rights**
(access, correction, deletion, opt-out), and complying with all applicable laws
and regulations — including, where relevant, the **GDPR**, **UK GDPR**,
**CCPA/CPRA**, and similar privacy, marketing, and anti-spam laws (e.g.
ePrivacy, **CAN-SPAM**, **CASL**, **TCPA**).

**3. Not a Consumer Reporting Agency.** This Actor and its operator are **not a
consumer reporting agency (CRA)**, and the output is **not a "consumer report"**
under the U.S. Fair Credit Reporting Act (**FCRA**) or similar laws. You must
**NOT** use it, in whole or in part, to decide a person's eligibility for
credit, employment, housing/tenancy, insurance, or any other FCRA-regulated
purpose.

**4. Respect third-party terms.** You are responsible for complying with the
terms of service of any website or platform whose public data you choose to
process, and with any applicable intellectual-property rights.

**5. No warranty.** The Actor is provided "as is", without warranty of any kind.
Inbox data and extracted signals may be incomplete, outdated, or inaccurate — verify independently
before relying on it. Availability of sources and fields can change at any time.

**6. Prohibited use.** Do not use this Actor or its output for stalking,
harassment, discrimination, fraud, spam, or any unlawful or harmful purpose.

**7. Indemnification.** You assume all risk and liability arising from your use
of this Actor, and **you agree to defend, indemnify and hold the operator
harmless** from any and all claims, losses, fines, or liabilities — including
reasonable legal fees — resulting from your use or misuse of the Actor or its
output, or from your breach of these terms or of any law.

> This section is general information, **not legal advice**. If you are unsure
> whether your intended use is permitted, consult your own legal counsel before
> running this Actor.

### Build a controlled disposable-inbox test

Use this temporary email API for test inboxes you create or are authorized to
read. Create the inbox first, keep the returned credentials private, and pass
its actual address and key to a later read. This workflow can test your own
transactional email and code-parsing flow; it does not provide access to someone
else's normal Gmail account or guarantee that a service accepts disposable mail.

| Goal | Starting action | What to verify |
| --- | --- | --- |
| One isolated QA mailbox | create with count1 | Returned address, provider and credentials |
| Check for a test message | read once with your own key | Empty result versus a retrieved message |
| Wait for a known notification | bounded read with sender/subject filters | Wait budget, source availability and message match |
| Parallel test cases | Small create count | Separate private credentials and per-inbox events |

#### Create one disposable test inbox

```json
{
  "action": "create",
  "domain": "auto",
  "count": 1
}
```

Creation returns inbox credentials, which belong in private workflow storage. No test email is sent by this request. Domain availability and creation time depend on the provider.

#### Create two independent test inboxes

```json
{
  "action": "create",
  "domain": "auto",
  "count": 2,
  "allowFallback": true
}
```

Two successful inboxes can mean two inbox-created events. Use the returned address/provider rather than assuming a requested branded domain was retained after fallback.

#### Read a mailbox you created, without waiting

```json
{
  "action": "read",
  "address": "YOUR_CREATED_INBOX_ADDRESS",
  "key": "YOUR_PRIVATE_INBOX_KEY",
  "waitTimeout": 0,
  "maxMessages": 1,
  "includeBody": false
}
```

The strings are placeholders, not usable credentials. Replace them privately with one create result. maxMessages limits returned messages; it does not authorize reading arbitrary addresses.

#### Wait briefly for your own QA notification

```json
{
  "action": "read",
  "address": "YOUR_CREATED_INBOX_ADDRESS",
  "key": "YOUR_PRIVATE_INBOX_KEY",
  "matchSubject": "Your test confirmation",
  "waitTimeout": 30,
  "pollInterval": 6,
  "latestOnly": true,
  "maxMessages": 1,
  "includeRaw": false
}
```

A waiting read is a separate operation from sending a test notification. Polling can end with no matching message, and a guessed OTP candidate still needs validation in your own test workflow.

### Credentials, retention and operation costs

Create output can contain token/password or provider-specific access values.
These are intended private user results, not examples to publish in Issues,
shared Tasks, screenshots, logs or public datasets. Mail bodies, OTP values and
verification URLs can also contain access secrets. Prefer a small projection
for downstream steps and keep the original credential record private.
Address-only disposable providers should not be treated as confidential storage.
Do not send real account recovery, financial or production secrets to a temporary
mailbox. Gmail-style provider options are not authentication to an existing
personal Gmail account.

Current events are $0.003 per inbox created, $0.01 per retrieved message and a
configured $0.01 mail-wait event. Startup is $0.002 per allocated GB, minimum one
event; platform usage is separate. The current source explicitly charges inbox
creation and delivered messages, but does not call the configured mail-wait
event. Inspect actual settled events rather than assuming every configured
event is used. One inbox create is $0.003 plus startup/resources. An empty read
has no message event, but startup/resources still apply; it is not an entirely
free run. Re-reading a delivered message can charge it again.

onlyUnseen filters provider-returned seen flags; it is not a universal
cross-run delivery ledger. waitForNew snapshots existing IDs
at that read's start; if the message arrived earlier it can be excluded. Keep
an external test-case/message ledger when repeat delivery matters. Filters use
available sender/subject/body text, and OTP extraction is heuristic rather than
proof that the first number is the intended code.

Only create was exercised by this documentation QA: no messages were sent and
no message/OTP/attachment-retrieval success is claimed for that check. JSON is
appropriate for credential and nested message fields; export only selected
non-secret columns into a shared sheet. Use the actual returned provider and
supported key input in the existing n8n/Python integration.

**Is a temporary inbox permanent or confidential?** No retention or availability
is guaranteed. Provider lifecycle and address-only access models limit its use.

**Does an empty read prove delivery failed?** No. The message may be delayed,
filtered, rejected by the sender, removed or outside the selected polling window.

### n8n and developer integrations

Use this Actor in your automation or application with the existing community integrations below. An Apify account and API token are required; Actor and platform charges follow the [current pricing](https://apify.com/apivault_labs/temp-email/pricing).

- **n8n community node:** [n8n-nodes-apivault-temp-email](https://www.npmjs.com/package/n8n-nodes-apivault-temp-email). Install package name `n8n-nodes-apivault-temp-email` in a self-hosted n8n instance that permits community packages.
- **Python client and examples:** [GitHub](https://github.com/apivault-labs/temp-email-python).
- **n8n source and usage:** [GitHub](https://github.com/apivault-labs/apivault-labs/tree/main/community-nodes/n8n-nodes-apivault-temp-email).

These are community packages. Publication on npm does not establish n8n verification or availability in n8n Cloud. Review the linked package README for supported inputs and setup.

# Changelog

This Actor's version history is a separate document: https://apify.com/apivault_labs/temp-email/changelog.md

# Actor input Schema

## `action` (type: `string`):

create = make a new inbox (returns its address + key instantly). read = check an existing inbox for messages.

## `domain` (type: `string`):

Only for Action = Create. Pick the address domain: Auto (fastest random), a branded domain, or a Gmail alias.

## `username` (type: `string`):

Only for the Auto domain - the local part of the address. Random if empty. Ignored for branded/Gmail domains.

## `count` (type: `integer`):

Only for Action = Create. Create this many disposable inboxes in one run (1-25). Each inbox is one result.

## `allowFallback` (type: `boolean`):

Only for Action = Create. If a branded/Gmail inbox can't be set up, create a reliable Auto inbox instead (recommended).

## `address` (type: `string`):

The email address to check (the one a Create run returned). The Domain field is ignored when reading.

## `inboxes` (type: `array`):

Only for Action = Read. Check several inboxes in one run. Paste a list of objects like \[{"address":"a@x.com","key":"..."}]. Branded/Gmail inboxes open with just the address; Auto inboxes need their key/token. Takes a single snapshot per inbox (no long polling).

## `key` (type: `string`):

For an Auto inbox: paste the 'token' from create (required). For branded/Gmail inboxes you can leave this EMPTY - they open with just the address.

## `password` (type: `string`):

Only for an Auto-domain inbox if its key/token expired - the password returned at create time.

## `waitTimeout` (type: `integer`):

For action=read. Default 0 = check once and return instantly (fast & cheap). Set a value (e.g. 60) only if you want to keep waiting for a mail to arrive. Max 120s.

## `pollInterval` (type: `integer`):

How often to check the inbox while waiting. Branded inboxes are rate-limited, so a minimum of ~12s is enforced automatically.

## `matchFrom` (type: `string`):

Only for Action = Read. Only return emails whose sender address or name contains this text (case-insensitive). The run keeps waiting until a matching mail arrives.

## `matchSubject` (type: `string`):

Only for Action = Read. Only return emails whose subject contains this text (case-insensitive).

## `matchKeyword` (type: `string`):

Only for Action = Read. Only return emails that contain this text anywhere (subject or body). Enables full-body fetch automatically.

## `onlyUnseen` (type: `boolean`):

Only for Action = Read. Skip messages already marked as seen.

## `waitForNew` (type: `boolean`):

Only for Action = Read. Ignore messages already in the inbox when the run begins - handy when re-testing the same address.

## `latestOnly` (type: `boolean`):

Only for Action = Read. Return just the most recent matching email (e.g. to grab the latest OTP). Reduces results.

## `maxMessages` (type: `integer`):

Only for Action = Read. Cap how many matching emails are returned (0 = no limit). Ignored when 'Return only the newest message' is on.

## `extractCodes` (type: `boolean`):

Scan message bodies and pull out likely one-time codes and verification links.

## `includeBody` (type: `boolean`):

Include the full text/HTML body of each message.

## `codeMinLength` (type: `integer`):

Shortest digit/alphanumeric code to treat as an OTP.

## `codeMaxLength` (type: `integer`):

Longest digit/alphanumeric code to treat as an OTP.

## `codeRegex` (type: `string`):

Advanced: a regex to extract the code yourself (first capture group, or whole match, is used). Overrides the length-based detection.

## `includeRaw` (type: `boolean`):

Also return the raw email source plus parsed headers and SPF/DKIM/DMARC verdicts (Auto inboxes only). Useful for deliverability QA.

## Actor input object example

```json
{
  "action": "create",
  "domain": "auto",
  "username": "",
  "count": 1,
  "allowFallback": true,
  "address": "",
  "inboxes": [],
  "key": "",
  "password": "",
  "waitTimeout": 0,
  "pollInterval": 6,
  "matchFrom": "",
  "matchSubject": "",
  "matchKeyword": "",
  "onlyUnseen": false,
  "waitForNew": false,
  "latestOnly": false,
  "maxMessages": 0,
  "extractCodes": true,
  "includeBody": true,
  "codeMinLength": 4,
  "codeMaxLength": 8,
  "codeRegex": "",
  "includeRaw": false
}
```

# Actor output Schema

## `results` (type: `string`):

Structured mailbox and message records from the default Dataset.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "username": "",
    "address": "",
    "inboxes": [],
    "key": "",
    "password": "",
    "matchFrom": "",
    "matchSubject": "",
    "matchKeyword": "",
    "codeRegex": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/temp-email").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "username": "",
    "address": "",
    "inboxes": [],
    "key": "",
    "password": "",
    "matchFrom": "",
    "matchSubject": "",
    "matchKeyword": "",
    "codeRegex": "",
}

# Run the Actor and wait for it to finish
run = client.actor("apivault_labs/temp-email").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "username": "",
  "address": "",
  "inboxes": [],
  "key": "",
  "password": "",
  "matchFrom": "",
  "matchSubject": "",
  "matchKeyword": "",
  "codeRegex": ""
}' |
apify call apivault_labs/temp-email --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apivault_labs/temp-email"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/r6y7sasrtRGGjTkwy/builds/IldB6iy06pUmLdqne/openapi.json