# Yahoo Email Accounts | Creation & Credentials (`cmfapps/findandflip-yahoo-email-accounts`) Actor

Create customer-owned Yahoo email accounts and retrieve credentials privately. Pay $2 through Apify per successful account, with no charge for failed creation.

- **URL**: https://apify.com/cmfapps/findandflip-yahoo-email-accounts.md
- **Developed by:** [Cody F](https://apify.com/cmfapps) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2,000.00 / 1,000 yahoo account createds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Yahoo Email Account Creation

Request customer-owned Yahoo email accounts and retrieve successfully created account credentials through the run's OUTPUT record.

### Pricing and access

Apify charges **$2 per successfully created account**, when the order has finished and you retrieve its credentials through the Actor. Failed creations are not charged. A partially successful order is charged only for the successful count. There is no paid start or dataset-item event.

No Find & Flip account, API key, or prepaid balance is required. Your verified Apify account owns the orders, and purchases are billed exclusively through Apify. Free-tier accounts can purchase using available Apify credit; the run spending limit must cover the requested purchase.

Set the Apify run spending limit to at least `$2 x count` before creating an order. For a later status/credentials run, allow enough to pay for any successful accounts not already paid. Check Apify Console's run pricing before starting.

### Example

```json
{
  "action": "create",
  "requestId": "yahoo-batch-001",
  "count": 1,
  "waitForCompletion": true,
  "maxWaitSeconds": 1800
}
```

Save the order UUID from OUTPUT. Reuse the same `requestId` and inputs if creation times out or the Actor restarts. A new ID creates a separate order. For a single account, you may supply both `firstName` and `lastName`; leave both blank for generated names. Bulk orders use generated names.

For later status or credential retrieval, copy the **`id` returned in OUTPUT** into `orderId`. Your custom `requestId` identifies a creation request; it is different from the generated order ID. You can also use `list` to find your order IDs.

```json
{
  "action": "credentials",
  "orderId": "11111111-1111-4111-8111-111111111111",
  "waitForCompletion": false
}
```

Replace the example UUID with the actual `id` from your order. Supplying `orderId` during `create` does not assign an ID to the new order.

### Actions

| Action | Purpose |
| --- | --- |
| `pricing` | Read the standard Apify price and availability. |
| `create` | Queue 1-100 accounts using a stable `requestId`. |
| `status` | Poll an owned order and, once fulfilled or terminal, pay for successes and retrieve credentials. |
| `credentials` | Complete payment if needed and retrieve credentials from an owned order. |
| `list` | List your orders with `limit` (1-100) and `offset`. |
| `cancel` | Stop unfinished work. Already created accounts remain part of the order and can be retrieved through status/credentials. |

`waitForCompletion` defaults to true and polls every ten seconds. `maxWaitSeconds` accepts 10-21600 seconds, default 1800. Account-creation availability, queue load, and provider responses affect completion time. Configure a compatible Apify run timeout with time for output export.

Creation defaults to eight parallel attempts even for one requested email. Once the requested quota is ready, spare attempts stop unless already requesting or waiting for SMS. Extra successful mailboxes become internal inventory and are never included in your bill or credentials. Fully fulfilled orders can be paid and retrieved immediately while protected spare flows finish in the background.

Stopping or timing out the Actor does not cancel the underlying order. Run `status` with its UUID to resume, or `cancel` to stop unfinished creation. Use the same Apify account for subsequent actions.

### Output and payment recovery

Progress responses contain `id`, `status`, `requestedCount`, `createdCount`, and billing details. Once the requested quota is ready (or a partial order has ended) and payment is verified, OUTPUT includes an `accounts` array with each purchased account's ID, email, password, first name, and last name. Credentials are not written to the dataset or logs by this Actor.

Duplicate reads of a paid order do not create another purchase event. If a charge confirmation is lost, the service checks the saved payment claim against Apify's recorded event count. An uncertain claim may require support review instead of another charge. Keep the existing order ID rather than creating a replacement order.

### Privacy and support

Generated credentials are sensitive. Keep inputs, OUTPUT records, and runs private, and change account passwords after retrieval when appropriate. Never select a real credential-bearing run as public sample output. The service retains provisioning and payment records to fulfill orders, attribute account ownership, and prevent duplicate charges. Your run token is used transiently for receipt verification and is not persisted by the backend.

Use the Actor's Issues tab for support with the run/order IDs only. Do not post API keys, email addresses, or passwords in public issues. This independent tool is not affiliated with, sponsored by, or endorsed by Yahoo. Use created accounts only for authorized purposes and in accordance with the provider's and Apify's terms. Creation does not guarantee future availability, acceptance, or account longevity.

# Actor input Schema

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

Standard Apify price: $2 per successfully created account. Only completed creations are billed, when credentials are requested through the Actor.

## `requestId` (type: `string`):

Your custom ID for create: 1-100 letters, numbers, hyphens or underscores. Reuse the SAME ID and input after any timeout or Actor restart. A new ID means a new order. This is different from the generated orderId returned in OUTPUT.

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

Maximum number of Yahoo accounts requested (1–100). Set the Apify spending limit to at least $2 times this count. Failed creations are not charged.

## `firstName` (type: `string`):

Optional, for one email only. Supply both names to generate the address from them.

## `lastName` (type: `string`):

Optional last name for a single-account order. Supply it together with firstName, or leave both names blank.

## `orderId` (type: `string`):

For status, credentials, or cancel, copy the generated id from a create run's OUTPUT or an item returned by list, including all hyphens. Do not enter your requestId or a number here. This field is ignored by create. Only orders owned by your verified Apify account are accessible.

## `waitForCompletion` (type: `boolean`):

For create or status, poll every 10 seconds. Waiting uses Apify compute time. Stopping the Actor does not cancel the order.

## `maxWaitSeconds` (type: `integer`):

Maximum time to wait for order completion when waiting is enabled. Waiting consumes Apify compute time.

## `limit` (type: `integer`):

Maximum number of your email creation orders to return for the list action.

## `offset` (type: `integer`):

Number of email creation orders to skip for list pagination. Start at 0.

## Actor input object example

```json
{
  "action": "pricing",
  "count": 1,
  "waitForCompletion": true,
  "maxWaitSeconds": 60,
  "limit": 20,
  "offset": 0
}
```

# Actor output Schema

## `result` (type: `string`):

No description

# 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 = {
    "action": "pricing",
    "waitForCompletion": false,
    "maxWaitSeconds": 60
};

// Run the Actor and wait for it to finish
const run = await client.actor("cmfapps/findandflip-yahoo-email-accounts").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 = {
    "action": "pricing",
    "waitForCompletion": False,
    "maxWaitSeconds": 60,
}

# Run the Actor and wait for it to finish
run = client.actor("cmfapps/findandflip-yahoo-email-accounts").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 '{
  "action": "pricing",
  "waitForCompletion": false,
  "maxWaitSeconds": 60
}' |
apify call cmfapps/findandflip-yahoo-email-accounts --silent --output-dataset

```

## MCP server setup

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

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/us3B7GquLrXKC4sfH/builds/kA3MczrX7TNiVEdS8/openapi.json