# Ecommerce Lookalike & Niche Discovery (`pequod-labs/ecommerce-lookalike-discovery`) Actor

Find qualified independent ecommerce stores from a seed domain or a niche + country. Optional addons per lead: marketing/tech signals dossier, shipping intelligence, decision-maker contact with verified email. No API keys needed.

- **URL**: https://apify.com/pequod-labs/ecommerce-lookalike-discovery.md
- **Developed by:** [Pequod](https://apify.com/pequod-labs) (community)
- **Categories:** Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $150.00 / 1,000 qualified store leads

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Ecommerce Lookalike & Niche Discovery

**Type a niche and a country — or paste a reference store — and get back qualified independent ecommerce stores, each optionally enriched with a marketing-signals dossier, shipping intelligence and a decision maker with a verified email.**

No API keys, no scraping setup. Describe who you're hunting; get outreach-ready leads.

### Why this Actor

Building a prospect list of independent online stores by hand means hours of Googling, opening sites one by one to check they actually sell and ship physical products, and then separately hunting down the owner's email. This Actor runs that whole workflow:

- **Discovery** — AI-generated localized search queries for your niche or seed store, then a funnel of qualification gates (blacklists, storefront-platform detection, an AI check that the site really sells physical shipped goods) filters hundreds of candidates down to real independent stores
- **Signals dossier** *(addon, modular)* — pick the signal families you care about: tech stack & domain age, Meta page & active ads, Google Ads activity, Trustpilot reviews, Instagram, traffic & order-volume estimate, LinkedIn headcount. A **0-10 composite score** renormalizes over whatever subset you chose, so leads stay comparable
- **Shipping intelligence** *(addon)* — which carriers ship the orders, how returns work (self-service portal and its vendor, or plain email), where free shipping starts, pickup/PUDO options and the shipping software behind the store
- **Decision maker** *(addon)* — the owner/CEO/founder with an SMTP-verified work email, phone and LinkedIn profile, with a verified generic inbox (`info@`, `contatti@`, …) as fallback

### Modes

| Mode | You provide | You get |
|------|-------------|---------|
| **Niche** | A vertical in plain words + a country (`"motorbike helmets and parts"`, IT) | Independent stores in that niche and market |
| **Lookalike** | A seed store domain (`vidaxl.nl`) + optionally a niche hint | Stores similar to the seed, excluding the seed itself |

Supported markets: **IT, DE, FR, NL, ES, GB, US** — search language, TLD filters and query strategies localize automatically.

### Quick start

```json
{
  "mode": "niche",
  "niche": "motorbike helmets and parts",
  "country": "IT",
  "maxResults": 30
}
````

Lookalike mode:

```json
{
  "mode": "lookalike",
  "seedDomain": "vidaxl.nl",
  "niche": "garden furniture and parasols",
  "country": "NL",
  "maxResults": 40
}
```

Only the signals you need:

```json
{
  "mode": "niche",
  "niche": "organic skincare",
  "country": "DE",
  "signals": ["reviews", "traffic", "metaAds"],
  "shippingIntel": false,
  "decisionMaker": true
}
```

#### Input options

- **mode** — `niche` (default) or `lookalike`
- **niche** — plain-words vertical; required in niche mode, optional steering in lookalike mode
- **seedDomain** — reference store; required in lookalike mode
- **country** — `IT`, `DE`, `FR`, `NL`, `ES`, `GB`, `US`
- **maxResults** (default 30) — upper bound on delivered leads; you only pay for delivered leads
- **discoveryDepth** — `quick` (one keyword round), `standard` (adds an AI keyword-expansion round when the first pass falls short), `deep` (up to three rounds, more search pages — best for narrow niches)
- **nicheFocus** — how far the AI keyword generation may drift from your niche: `strict` (stay inside the micro-niche — precision over volume), `balanced` (default), `broad` (adjacent verticals and umbrella categories — more leads, less niche-pure)
- **signalsAddon** / **signals** — toggle the dossier and pick the modules: `techStack`, `metaAds`, `googleAds`, `reviews`, `instagram`, `traffic`, `linkedin`
- **shippingIntel** — carriers, returns, thresholds, shipping software per lead
- **decisionMaker** — named contact with verified email (+ **verifyEmails**, **includeGenericInbox** in Advanced)
- **excludeDomains** — skip your customers or already-contacted shops
- **proxyConfiguration** — Apify Proxy for the direct page fetches (shipping intelligence)

### Example output

```json
{
  "domain": "casco-moto.it",
  "country": "IT",
  "status": "new",
  "micro_niche": "motorbike helmets and accessories",
  "tier": "tier2",
  "confidence_score": 0.9,
  "traffic_monthly": 85000,
  "platform": "prestashop",
  "composite_score": 8,
  "signals": {
    "composite_score": 8,
    "signals_collected": ["metaAds", "reviews", "techStack", "traffic"],
    "fb_ads_active": true,
    "tools_count": 7,
    "tp_priority_score": 3,
    "dossier": { "tools": ["PrestaShop", "Klaviyo"], "orders_est": 1020, "...": "..." }
  },
  "shipping": {
    "carriers": ["BRT", "GLS"],
    "return_portal_state": "self_service",
    "returns_portal": "Sendcloud",
    "free_shipping_threshold_eur": 49.0,
    "pickup_state": "available"
  },
  "decision_maker": {
    "full_name": "Marco Rossi",
    "role": "CEO & Founder",
    "email": "marco.rossi@casco-moto.it",
    "email_sendable": true,
    "linkedin_url": "https://linkedin.com/in/marcorossi"
  },
  "best_contact_email": "marco.rossi@casco-moto.it",
  "has_contact": true
}
```

#### Key output fields

| Field | Description |
|-------|-------------|
| `domain`, `country` | Discovered store and inferred HQ country |
| `micro_niche`, `industry`, `products_sold` | What the store sells, extracted during qualification |
| `tier`, `confidence_score` | Size tier and qualification confidence |
| `platform` | Detected storefront platform (Shopify, PrestaShop, Magento, …) |
| `composite_score` | 0-10 prospect score over the signal modules you selected |
| `signals.dossier` | Full raw dossier of the collected signal families |
| `shipping.*` | Carriers, returns portal & vendor, free-shipping threshold, pickup, shipping software |
| `decision_maker.*` | Name, role, verified email with status, phone, LinkedIn |
| `best_contact_email` | The one email to use: decision maker first, generic inbox as fallback |

### Who uses it

| You are | You get |
|---------|---------|
| **Logistics / shipping SaaS sales** | Stores with their carriers, returns setup and current shipping software — plus who to email |
| **Ecommerce agency / SaaS vendor** | Niche + market prospect lists scored by ad activity, traffic and tech stack |
| **Lead-gen agency** | A full pipeline — discovery, scoring, enrichment, verified contact — in one run |
| **Marketplace / brand doing competitor research** | Every independent store in a vertical with traffic and ads intelligence |

### Reliability & billing

- **You only pay for delivered leads.** Domains filtered out by the gates are free and listed in the `REJECTED_DOMAINS` record of the key-value store with the rejection reason
- Each addon is billed as its own event only when it actually produced data for a lead; a verified contact is a separate premium event
- The run's **maximum cost limit is honored**: the lead target and addon enrichment are capped to what the limit allows before any upstream work is paid for
- The `RUN_SUMMARY` record gives per-run coverage at a glance: leads delivered, discovery rounds, addon coverage
- Results stream into the dataset progressively — no waiting for the whole run to finish

### Limitations

- Niches with very few independent stores may return fewer leads than `maxResults` even at `deep` depth — the summary tells you how many rounds ran
- Traffic and order-volume figures are estimates (modeled from public traffic data), best used for ranking rather than as absolutes
- Decision-maker coverage is strongest for European and US companies; catch-all mail servers can't be proven deliverable and are never marked sendable
- Signals depend on public footprints: stores without a Facebook page, Trustpilot profile or Instagram simply score lower on those parts

### Questions or feature requests?

Open an issue on the Actor's page — feedback on new markets, signal modules or output fields is welcome.

# Actor input Schema

## `mode` (type: `string`):

<b>Niche</b>: describe a vertical and pick a country. <b>Lookalike</b>: give a reference store domain and get similar independent shops.

## `niche` (type: `string`):

What kind of stores to find, in plain words — e.g. <code>organic skincare</code>, <code>motorbike helmets and parts</code>, <code>tuinmeubelen</code>. Required in niche mode; in lookalike mode it optionally steers the search.

## `seedDomain` (type: `string`):

Reference store to find similar shops for, e.g. <code>vidaxl.nl</code>. Required in lookalike mode.

## `country` (type: `string`):

Market to search in — drives search language, TLD filters and localized query strategies.

## `maxResults` (type: `integer`):

Upper bound on qualified stores delivered to the dataset. You only pay for delivered leads.

## `discoveryDepth` (type: `string`):

How hard to dig. <b>Quick</b>: one keyword round, fastest. <b>Standard</b>: adds an AI keyword-expansion round when the first pass falls short of the target. <b>Deep</b>: up to three rounds and more search pages per query — best coverage for narrow niches.

## `nicheFocus` (type: `string`):

How far the AI keyword generation may drift from your niche. <b>Strict</b>: stays inside the micro-niche (sub-niches and long-tail only) — precision over volume. <b>Balanced</b>: mostly in-niche, one adjacent angle allowed. <b>Broad</b>: adjacent verticals and umbrella categories too — more leads, less niche-pure.

## `signals` (type: `array`):

Which signal families to collect per lead. Deselect what you don't need — only selected modules are fetched and the 0-10 composite score renormalizes over them.

## `signalsAddon` (type: `boolean`):

Collect the selected signal modules for every lead and compute a 0-10 composite score. Billed as a separate event per enriched lead.

## `shippingIntel` (type: `boolean`):

Detect carriers, returns process & portal vendor, free-shipping threshold, pickup points and shipping software behind each store. Billed as a separate event per enriched lead.

## `decisionMaker` (type: `boolean`):

Find the owner/CEO/founder of each store with an SMTP-verified work email, phone and LinkedIn profile. A verified contact is billed as a separate premium event.

## `excludeDomains` (type: `array`):

Domains to skip — e.g. your existing customers or shops you already contacted.

## `verifyEmails` (type: `boolean`):

Recommended. SMTP-level verification on decision-maker emails; only top-quality passes are marked sendable.

## `includeGenericInbox` (type: `boolean`):

When no verified decision-maker email is found, try localized generic inboxes (<code>info@</code>, <code>kontakt@</code>, <code>contatti@</code>, …) so you still get a working contact channel.

## `proxyConfiguration` (type: `object`):

Apify Proxy for the direct page fetches (shipping intelligence). Avoids IP blocks from ecommerce WAFs.

## Actor input object example

```json
{
  "mode": "niche",
  "niche": "motorbike helmets and parts",
  "seedDomain": "",
  "country": "IT",
  "maxResults": 30,
  "discoveryDepth": "standard",
  "nicheFocus": "balanced",
  "signals": [
    "techStack",
    "metaAds",
    "googleAds",
    "reviews",
    "instagram",
    "traffic"
  ],
  "signalsAddon": true,
  "shippingIntel": true,
  "decisionMaker": true,
  "excludeDomains": [],
  "verifyEmails": true,
  "includeGenericInbox": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `leads` (type: `string`):

No description

## `rejectedDomains` (type: `string`):

No description

## `runSummary` (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 = {
    "niche": "motorbike helmets and parts",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("pequod-labs/ecommerce-lookalike-discovery").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 = {
    "niche": "motorbike helmets and parts",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("pequod-labs/ecommerce-lookalike-discovery").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 '{
  "niche": "motorbike helmets and parts",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call pequod-labs/ecommerce-lookalike-discovery --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=pequod-labs/ecommerce-lookalike-discovery",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ecommerce Lookalike & Niche Discovery",
        "description": "Find qualified independent ecommerce stores from a seed domain or a niche + country. Optional addons per lead: marketing/tech signals dossier, shipping intelligence, decision-maker contact with verified email. No API keys needed.",
        "version": "0.2",
        "x-build-id": "W6wNjv3ylc0OwcH2a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/pequod-labs~ecommerce-lookalike-discovery/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-pequod-labs-ecommerce-lookalike-discovery",
                "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/pequod-labs~ecommerce-lookalike-discovery/runs": {
            "post": {
                "operationId": "runs-sync-pequod-labs-ecommerce-lookalike-discovery",
                "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/pequod-labs~ecommerce-lookalike-discovery/run-sync": {
            "post": {
                "operationId": "run-sync-pequod-labs-ecommerce-lookalike-discovery",
                "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",
                "required": [
                    "country"
                ],
                "properties": {
                    "mode": {
                        "title": "Discovery mode",
                        "enum": [
                            "niche",
                            "lookalike"
                        ],
                        "type": "string",
                        "description": "<b>Niche</b>: describe a vertical and pick a country. <b>Lookalike</b>: give a reference store domain and get similar independent shops.",
                        "default": "niche"
                    },
                    "niche": {
                        "title": "Niche / vertical",
                        "type": "string",
                        "description": "What kind of stores to find, in plain words — e.g. <code>organic skincare</code>, <code>motorbike helmets and parts</code>, <code>tuinmeubelen</code>. Required in niche mode; in lookalike mode it optionally steers the search."
                    },
                    "seedDomain": {
                        "title": "Seed domain (lookalike mode)",
                        "type": "string",
                        "description": "Reference store to find similar shops for, e.g. <code>vidaxl.nl</code>. Required in lookalike mode.",
                        "default": ""
                    },
                    "country": {
                        "title": "Target country",
                        "enum": [
                            "IT",
                            "DE",
                            "FR",
                            "NL",
                            "ES",
                            "GB",
                            "US"
                        ],
                        "type": "string",
                        "description": "Market to search in — drives search language, TLD filters and localized query strategies.",
                        "default": "IT"
                    },
                    "maxResults": {
                        "title": "Max leads to deliver",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Upper bound on qualified stores delivered to the dataset. You only pay for delivered leads.",
                        "default": 30
                    },
                    "discoveryDepth": {
                        "title": "Discovery depth",
                        "enum": [
                            "quick",
                            "standard",
                            "deep"
                        ],
                        "type": "string",
                        "description": "How hard to dig. <b>Quick</b>: one keyword round, fastest. <b>Standard</b>: adds an AI keyword-expansion round when the first pass falls short of the target. <b>Deep</b>: up to three rounds and more search pages per query — best coverage for narrow niches.",
                        "default": "standard"
                    },
                    "nicheFocus": {
                        "title": "Niche focus",
                        "enum": [
                            "strict",
                            "balanced",
                            "broad"
                        ],
                        "type": "string",
                        "description": "How far the AI keyword generation may drift from your niche. <b>Strict</b>: stays inside the micro-niche (sub-niches and long-tail only) — precision over volume. <b>Balanced</b>: mostly in-niche, one adjacent angle allowed. <b>Broad</b>: adjacent verticals and umbrella categories too — more leads, less niche-pure.",
                        "default": "balanced"
                    },
                    "signals": {
                        "title": "Signal modules",
                        "type": "array",
                        "description": "Which signal families to collect per lead. Deselect what you don't need — only selected modules are fetched and the 0-10 composite score renormalizes over them.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "techStack",
                                "metaAds",
                                "googleAds",
                                "reviews",
                                "instagram",
                                "traffic",
                                "linkedin"
                            ],
                            "enumTitles": [
                                "Tech stack & domain age",
                                "Meta (Facebook) page & active ads",
                                "Google Ads activity",
                                "Trustpilot reviews",
                                "Instagram profile",
                                "Traffic & order volume estimate",
                                "LinkedIn company (headcount, HQ)"
                            ]
                        },
                        "default": [
                            "techStack",
                            "metaAds",
                            "googleAds",
                            "reviews",
                            "instagram",
                            "traffic"
                        ]
                    },
                    "signalsAddon": {
                        "title": "Signals dossier addon",
                        "type": "boolean",
                        "description": "Collect the selected signal modules for every lead and compute a 0-10 composite score. Billed as a separate event per enriched lead.",
                        "default": true
                    },
                    "shippingIntel": {
                        "title": "Shipping intelligence addon",
                        "type": "boolean",
                        "description": "Detect carriers, returns process & portal vendor, free-shipping threshold, pickup points and shipping software behind each store. Billed as a separate event per enriched lead.",
                        "default": true
                    },
                    "decisionMaker": {
                        "title": "Decision-maker addon",
                        "type": "boolean",
                        "description": "Find the owner/CEO/founder of each store with an SMTP-verified work email, phone and LinkedIn profile. A verified contact is billed as a separate premium event.",
                        "default": true
                    },
                    "excludeDomains": {
                        "title": "Exclude domains",
                        "type": "array",
                        "description": "Domains to skip — e.g. your existing customers or shops you already contacted.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "verifyEmails": {
                        "title": "Verify email deliverability",
                        "type": "boolean",
                        "description": "Recommended. SMTP-level verification on decision-maker emails; only top-quality passes are marked sendable.",
                        "default": true
                    },
                    "includeGenericInbox": {
                        "title": "Generic inbox fallback",
                        "type": "boolean",
                        "description": "When no verified decision-maker email is found, try localized generic inboxes (<code>info@</code>, <code>kontakt@</code>, <code>contatti@</code>, …) so you still get a working contact channel.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy for the direct page fetches (shipping intelligence). Avoids IP blocks from ecommerce WAFs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
