# Email Finder & Verifier — Bulk Company & Domain Email Lookup (`memo23/email-finder`) Actor
Find AND verify business emails in bulk from company names or domains. Discovers the website, scrapes emails, ranks role addresses, then validates each one — syntax, MX record, disposable/role/free flags — so you export deliverable addresses, not just candidates. CSV/JSON/API.
- **URL**: https://apify.com/memo23/email-finder.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Lead generation, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $10.00 / 1,000 company enricheds
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/platform/actors/running/actors-in-store#pay-per-event
## What's an Apify Actor?
Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".
## 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.
The best way to integrate Actors is as follows.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):
```bash
pip install apify-client
```
In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):
````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash
In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).
If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).
For usage examples, see the [API](#api) section below.
For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).
# README
## Email Finder
Turn a list of **company names or domains** into contactable **business email addresses** — in bulk. Give it a domain and it scrapes the company's own site for emails; give it a company name and it discovers the website first, then finds the emails. Every row comes back with the resolved website, ranked emails, the source, and a confidence signal.
### Why Use This Scraper?
- **Two ways in.** Already have the domain? It scrapes the site directly (most accurate). Only have the company name? It discovers the website first, then finds the emails.
- **Bulk by design.** Paste an array, a spreadsheet column, or a comma-separated blob of hundreds of companies and get one clean row back per company.
- **Role emails ranked first.** Generic outreach addresses (`info@`, `sales@`, `support@`, `hello@`) float to the top of each company's results, with junk and placeholder addresses (`name@example.com`, `no-reply@`) stripped out.
- **Pay only for hits.** Flip `onlyWithEmails` and you're charged only for companies where at least one email was actually found.
- **Every row is qualified.** Each result carries a `source` (site-scrape / hunter) and a `confidence` signal so you can filter for quality before you import.
- **Find *and* verify, in one pass.** Flip `verifyEmails` and every address is validated — syntax, MX record (does the domain accept mail?), plus disposable / role / free-provider flags — returning `validEmails` and a `bestValidEmail` so you export deliverable addresses, not just candidates. No second tool, no second export.
- **Optional Hunter.io fallback.** Supply your own Hunter.io key to add a paid domain-search fallback for companies where the on-site scrape comes up empty.
### Overview
Email Finder is a **bulk business-email discovery** tool. Feed it companies — by domain, by name, or both — and it returns the best contact emails it can find for each, with provenance.
It works in two modes, which you can mix freely in one run:
- **Track A — domain in.** You pass a website (e.g. `stripe.com`). The actor scrapes the company's own contact pages for `mailto:` links and on-page addresses. This is the most accurate path because there's no guessing about which company you mean.
- **Track B — name in.** You pass a company name (e.g. `"Notion Labs"`). The actor first resolves the name to a website, applies a name-match precision guard so it doesn't attach the wrong company's domain, then scrapes that site for emails.
A realistic note on hit rates: emails are found for companies that actually **publish** a contact address on their site — which is most small and mid-sized businesses, agencies, shops, and firms (the typical lead-gen target). Large enterprises that hide behind a contact form return no on-page email; for those, the optional Hunter.io fallback helps. Every row tells you exactly where its emails came from, so quality is never a guess.
### Supported Inputs
Mix and match in one run — they're all merged and de-duplicated:
- **`domains`** — company websites/domains (Track A, most accurate).
- **`companyNames`** — company/brand names to resolve, then find emails (Track B).
- **`inputText`** — paste a blob of domains or names (new-line / comma / semicolon separated). Anything with a dot is treated as a domain; everything else as a company name.
- **`companies`** — advanced structured rows mixing `name` + `website` + `city`/`state` for best disambiguation.
### Use Cases
| Who | What they use it for |
| --- | --- |
| **Sales & lead-gen teams** | Turn a list of target companies into contactable emails for outbound outreach. |
| **Agencies & freelancers** | Build a prospect list for a niche (e.g. dentists, law firms, e-commerce shops) from names or domains. |
| **Recruiters** | Find a company's contact address when reaching out about candidates or partnerships. |
| **Market researchers** | Attach a contact email and resolved website to a list of companies for a study or directory. |
| **RevOps / data teams** | Enrich a CRM segment with business emails, source, and confidence in bulk. |
### How It Works
1. **Input** — give it domains, company names, or both (array, pasted list, or CSV blob), optionally with a city/state to disambiguate.
2. **Resolve & scrape** — for names, it resolves the website (and applies a name-match guard); then it scrapes the company's contact pages for `mailto:` links and on-page emails, strips junk and placeholder addresses, and ranks role emails first. If you supplied a Hunter.io key, it falls back to a domain search when the site scrape finds nothing.
3. **Export** — each company becomes one flat row (website, emails, source, confidence), streamed to the dataset for download as JSON, CSV, or Excel, or via the API.
### Input Configuration
| Field | Type | Description |
| --- | --- | --- |
| `domains` | array | Company websites/domains to find emails for (Track A, most accurate). |
| `companyNames` | array | Company names to resolve to a website, then find emails (Track B). |
| `inputText` | string | Paste a blob of domains or names (new-line / comma / semicolon separated). |
| `companies` | array | Advanced — structured `{ name, website, city, state }` rows. |
| `guardMode` | string | Domain-match strictness for discovery: `business` (default), `off`, `residential`. |
| `onlyWithEmails` | boolean | Emit only companies where an email was found — pay only for hits. |
| `verifyEmails` | boolean | Validate every found email (syntax + MX + disposable/role/free flags); adds `emailVerifications`, `validEmails`, `bestValidEmail`. Billed per email verified. |
| `hunterApiKey` | string | Optional Hunter.io API key for a paid domain-search fallback. |
| `maxItems` | integer | Hard cap on companies processed this run. |
| `maxConcurrency` | integer | How many companies to enrich in parallel. |
| `proxy` | object | Proxy configuration (Residential recommended). |
#### Example input
```json
{
"domains": ["ahrefs.com", "sitepoint.com"],
"companyNames": ["Basecamp"],
"inputText": "backlinko.com\nSmashing Magazine",
"guardMode": "business",
"onlyWithEmails": false
}
````
### Output Overview
Every company is emitted as one flat JSON object. Fields that don't resolve (e.g. no email found) come back `null` or empty rather than missing, so the schema stays consistent. Download as JSON, CSV, Excel, or via the Apify API.
### Output Samples
A domain that publishes emails (Track A):
```jsonc
{
"query": null,
"inputWebsite": "ahrefs.com",
"companyName": null,
"website": "https://ahrefs.com",
"email": "support@ahrefs.com",
"emails": ["support@ahrefs.com", "pr@ahrefs.com"],
"emailCount": 2,
"source": "site-scrape",
"confidence": "high",
"foundAt": "2026-07-08T05:20:41.000Z"
}
```
A company found by name (Track B):
```jsonc
{
"query": "Basecamp",
"inputWebsite": null,
"companyName": "Basecamp",
"website": "https://basecamp.com",
"email": "jason@basecamp.com",
"emails": ["jason@basecamp.com"],
"emailCount": 1,
"source": "site-scrape",
"confidence": "high",
"foundAt": "2026-07-08T05:20:42.000Z"
}
```
A company with no public email:
```jsonc
{
"query": null,
"inputWebsite": "mailchimp.com",
"website": "https://mailchimp.com",
"email": null,
"emails": [],
"emailCount": 0,
"source": "none",
"confidence": "low"
}
```
With **`verifyEmails: true`**, each row also carries validation — `validEmails` / `bestValidEmail` plus a per-address `emailVerifications` array:
```jsonc
{
// …the normal finder fields…
"validEmails": ["jane.doe@acme.com"],
"validEmailCount": 1,
"bestValidEmail": "jane.doe@acme.com",
"emailVerifications": [
{ "email": "jane.doe@acme.com", "syntaxValid": true, "domain": "acme.com", "mxFound": true,
"isDisposable": false, "isRoleBased": false, "isFreeProvider": false, "verdict": "valid" },
{ "email": "info@acme.com", "syntaxValid": true, "domain": "acme.com", "mxFound": true,
"isDisposable": false, "isRoleBased": true, "isFreeProvider": false, "verdict": "risky" }
]
}
```
`verdict` is `valid` (syntax + MX ok, not disposable), `risky` (role-based or free-provider), or `invalid` (bad syntax, no MX, or disposable).
### Key Output Fields
**Input echo**
- `query` — the company name you passed (Track B), else `null`
- `inputWebsite` — the domain you passed (Track A), else `null`
**Result**
- `website` — the resolved company website
- `email` — the single best email (role addresses first)
- `emails` — all emails found, ranked best-to-worst, de-duplicated
- `emailCount` — how many were found
**Provenance**
- `source` — `site-scrape`, `hunter`, or `none`
- `confidence` — `high` / `medium` / `low`
- `foundAt` — ISO timestamp
### FAQ
**What's the difference between passing a domain and a company name?**
A domain (Track A) is the most accurate — the actor scrapes exactly that site, no guessing. A company name (Track B) requires the actor to first resolve the name to a website, which it does via a company-directory lookup plus a name-match guard so it doesn't attach the wrong domain. If you have domains, prefer them.
**Why did some companies return no email?**
Because they don't publish one on their site — many large companies route everything through a contact form. The actor reports `source: "none"` for those so you always know. For hard cases, supply a Hunter.io API key to enable the paid fallback. Small and mid-sized businesses (the usual outreach targets) publish emails far more often.
**How are the emails ranked?**
Role/outreach addresses (`info@`, `sales@`, `contact@`, `support@`, `hello@`) are floated to the top, and obvious junk — tracking pixels, asset filenames, and placeholder addresses like `name@example.com` or `no-reply@` — is stripped out. The single best one is surfaced as `email`, the full ranked list as `emails`.
**Do I pay for companies where no email is found?**
Only if you want the full dataset. Set `onlyWithEmails: true` and rows with no email are dropped before they're written or charged, so you pay only for successful hits.
**Do I need a Hunter.io key?**
No — the free site-scrape path works on its own. A Hunter.io key is an optional fallback that kicks in only when the on-site scrape finds nothing, using your own Hunter quota.
**How fast is it, and how many companies can it handle?**
It enriches companies in parallel (tune `maxConcurrency`) and scales from a handful to thousands. Site scraping runs over a proxy, so use Residential proxies for the best success rate on large runs.
**What export formats are supported?**
Every run writes to an Apify dataset you can download as JSON, CSV, Excel, XML, or JSONL, or fetch via the Apify API — and wire into scheduling, webhooks, Google Sheets, Zapier, or Make.
### Support
- **Found a bug or need a new field?** Open a ticket on the **Issues** tab of this actor — it's the fastest way to reach me and I actively maintain this actor.
- **Email:**
- **Website:** [muhamed-didovic.github.io](https://muhamed-didovic.github.io/)
### Additional Services
Need something beyond the standard output? I build and maintain custom actors and data pipelines. Happy to help with:
- Email verification (syntax, MX, deliverability) as a follow-on step
- Person-level contact discovery (names, titles, LinkedIn) via a provider key
- Custom fields, filters, or export formats tailored to your workflow
- Private or dedicated actors for high-volume or compliance-sensitive use
Reach out via the Issues tab or email and describe what you need.
### Explore More Scrapers
Browse my other Apify actors — job boards, business directories, review sites, social platforms, and more — on my profile: [memo23 on Apify](https://apify.com/memo23).
### ⚠️ Disclaimer
This actor discovers **publicly available** business contact information — the same email addresses any visitor can see on a company's public website. It does not access private data, bypass authentication, or scrape gated content.
You are responsible for how you use the data you collect. Use it in compliance with applicable laws (including the GDPR, CAN-SPAM, CASL, and other data-protection and anti-spam regulations) and any contractual obligations you may have. Finding an email address does not constitute consent to contact it — ensure your outreach complies with the relevant marketing and messaging laws in your jurisdiction. Do not use this tool to facilitate spam, harassment, or any violation of privacy.
### SEO Keywords
email finder, bulk email finder, business email finder, company email lookup, domain email finder, email scraper, email extractor, find company emails, b2b email finder, lead generation tool, sales prospecting, contact email finder, email discovery, company contact scraper, domain to email, email hunter alternative, cold outreach emails, crm enrichment, bulk email lookup, email finder api
# Actor input Schema
## `domains` (type: `array`):
Company websites or domains to find emails for (most accurate — the site is scraped directly). One per entry, e.g. stripe.com or https://stripe.com.
## `companyNames` (type: `array`):
Company / brand names to discover a website for, then find emails. Use when you don't have the domain. One per entry.
## `inputText` (type: `string`):
Alternative — paste a blob of domains OR company names separated by new lines, commas, or semicolons. Domains (containing a dot) are treated as websites; everything else as a company name.
## `companies` (type: `array`):
Advanced: mix name + website + city/state per row for best disambiguation. Merged with the fields above.
## `guardMode` (type: `string`):
How strictly a discovered domain must match the company name. 'business' = name match (default, recommended). 'off' = accept any Clearbit match. 'residential' = property/real-estate mode.
## `onlyWithEmails` (type: `boolean`):
Emit only rows where at least one email was found — so you pay only for successful hits.
## `verifyEmails` (type: `boolean`):
Validate every email found: checks syntax, looks up the domain's MX record (does it accept mail?), and flags disposable, role-based (info@, sales@) and free-provider (gmail, etc.) addresses. Adds an `emailVerifications` array plus `validEmails`, `validEmailCount` and `bestValidEmail` — so you get deliverable addresses, not just candidates. (Reliable DNS/list-based validation; does not do live SMTP mailbox probing.) Billed per email verified.
## `qualifyByPayment` (type: `boolean`):
Scans each business's website — reusing the pages already fetched for email discovery, so no extra cost or time — for payment processors and e-commerce platforms (Stripe, Shopify, PayPal, Paddle, Lemon Squeezy, WooCommerce, Square, Chargebee and more). Adds `takesPayments` (is this a real paying business?), `paymentProcessors` (which stack), `stripeLiveKey` (the public key if exposed) and `paymentConfidence`. Turn raw contacts into monetization-qualified leads. No extra charge — included with each enriched company (billed under the existing Company enriched event).
## `hunterApiKey` (type: `string`):
Optional — supply your own Hunter.io key to enable a paid domain-search fallback when the site scrape finds no emails. Leave empty to use the free site-scrape path only.
## `maxItems` (type: `integer`):
Hard cap on how many companies to process this run.
## `maxConcurrency` (type: `integer`):
How many companies to enrich in parallel.
## `proxy` (type: `object`):
Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies.
## Actor input object example
```json
{
"domains": [
"stripe.com",
"notion.so"
],
"guardMode": "business",
"onlyWithEmails": false,
"verifyEmails": false,
"qualifyByPayment": false,
"maxItems": 100000,
"maxConcurrency": 10
}
```
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"domains": [
"stripe.com",
"notion.so"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("memo23/email-finder").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = { "domains": [
"stripe.com",
"notion.so",
] }
# Run the Actor and wait for it to finish
run = client.actor("memo23/email-finder").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{
"domains": [
"stripe.com",
"notion.so"
]
}' |
apify call memo23/email-finder --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=memo23/email-finder",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Email Finder & Verifier — Bulk Company & Domain Email Lookup",
"description": "Find AND verify business emails in bulk from company names or domains. Discovers the website, scrapes emails, ranks role addresses, then validates each one — syntax, MX record, disposable/role/free flags — so you export deliverable addresses, not just candidates. CSV/JSON/API.",
"version": "0.0",
"x-build-id": "zFgp9l28MOwmSO3Zu"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/memo23~email-finder/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-memo23-email-finder",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/acts/memo23~email-finder/runs": {
"post": {
"operationId": "runs-sync-memo23-email-finder",
"x-openai-isConsequential": false,
"summary": "Executes an Actor and returns information about the initiated run in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/runsResponseSchema"
}
}
}
}
}
}
},
"/acts/memo23~email-finder/run-sync": {
"post": {
"operationId": "run-sync-memo23-email-finder",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"components": {
"schemas": {
"inputSchema": {
"type": "object",
"properties": {
"domains": {
"title": "Websites / domains",
"type": "array",
"description": "Company websites or domains to find emails for (most accurate — the site is scraped directly). One per entry, e.g. stripe.com or https://stripe.com.",
"items": {
"type": "string"
}
},
"companyNames": {
"title": "Company names",
"type": "array",
"description": "Company / brand names to discover a website for, then find emails. Use when you don't have the domain. One per entry.",
"items": {
"type": "string"
}
},
"inputText": {
"title": "Paste a list",
"type": "string",
"description": "Alternative — paste a blob of domains OR company names separated by new lines, commas, or semicolons. Domains (containing a dot) are treated as websites; everything else as a company name."
},
"companies": {
"title": "Structured queries (advanced)",
"type": "array",
"description": "Advanced: mix name + website + city/state per row for best disambiguation. Merged with the fields above."
},
"guardMode": {
"title": "Match precision",
"enum": [
"business",
"off",
"residential"
],
"type": "string",
"description": "How strictly a discovered domain must match the company name. 'business' = name match (default, recommended). 'off' = accept any Clearbit match. 'residential' = property/real-estate mode.",
"default": "business"
},
"onlyWithEmails": {
"title": "Only output companies with emails",
"type": "boolean",
"description": "Emit only rows where at least one email was found — so you pay only for successful hits.",
"default": false
},
"verifyEmails": {
"title": "✅ Verify emails (find + validate in one pass, billed per email)",
"type": "boolean",
"description": "Validate every email found: checks syntax, looks up the domain's MX record (does it accept mail?), and flags disposable, role-based (info@, sales@) and free-provider (gmail, etc.) addresses. Adds an `emailVerifications` array plus `validEmails`, `validEmailCount` and `bestValidEmail` — so you get deliverable addresses, not just candidates. (Reliable DNS/list-based validation; does not do live SMTP mailbox probing.) Billed per email verified.",
"default": false
},
"qualifyByPayment": {
"title": "💳 Qualify by payment (flag businesses that take money online)",
"type": "boolean",
"description": "Scans each business's website — reusing the pages already fetched for email discovery, so no extra cost or time — for payment processors and e-commerce platforms (Stripe, Shopify, PayPal, Paddle, Lemon Squeezy, WooCommerce, Square, Chargebee and more). Adds `takesPayments` (is this a real paying business?), `paymentProcessors` (which stack), `stripeLiveKey` (the public key if exposed) and `paymentConfidence`. Turn raw contacts into monetization-qualified leads. No extra charge — included with each enriched company (billed under the existing Company enriched event).",
"default": false
},
"hunterApiKey": {
"title": "Hunter.io API key (optional)",
"type": "string",
"description": "Optional — supply your own Hunter.io key to enable a paid domain-search fallback when the site scrape finds no emails. Leave empty to use the free site-scrape path only."
},
"maxItems": {
"title": "Max companies",
"minimum": 1,
"type": "integer",
"description": "Hard cap on how many companies to process this run.",
"default": 100000
},
"maxConcurrency": {
"title": "Max concurrency",
"minimum": 1,
"maximum": 50,
"type": "integer",
"description": "How many companies to enrich in parallel.",
"default": 10
},
"proxy": {
"title": "Proxy configuration (optional override)",
"type": "object",
"description": "Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies."
}
}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```