# Empire Flippers Marketplace Scraper (`automation-lab/empire-flippers-marketplace-scraper`) Actor

Extract public Empire Flippers business listings with asking prices, monthly financials, valuation multiples, niches, workload, opportunities, risks, traffic, and status.

- **URL**: https://apify.com/automation-lab/empire-flippers-marketplace-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Empire Flippers Marketplace Scraper

Extract public online-business acquisition listings from Empire Flippers into clean, analysis-ready data.

Get asking prices, monthly revenue, net profit, expenses, valuation multiples, niches, monetization models, workload, trends, opportunities, risks, site traffic, and listing status without maintaining your own API integration.

Use the Actor for recurring deal sourcing, new-listing alerts, repricing monitors, status tracking, comparable-company research, and acquisition-market newsletters.

### What does Empire Flippers Marketplace Scraper do?

Empire Flippers Marketplace Scraper calls the official public Empire Flippers Marketplace API and creates one normalized dataset row per listing.

It supports two workflows:

- 🔎 **Marketplace discovery** — filter and paginate current, pending, or sold listings.
- 🎯 **Listing lookup** — retrieve one or more known Empire Flippers listing numbers.

The Actor preserves rich public source data while flattening it into fields that work well in JSON, CSV, Excel, Google Sheets, databases, and BI tools.

It does not access seller identity, gated diligence files, unlocked URLs, or private buyer-account data.

### Who is it for?

#### Acquisition entrepreneurs and search funds

Build a repeatable pipeline of online businesses matching your budget, earnings target, niche expertise, and preferred monetization model.

#### M&A advisors and business brokers

Monitor active inventory, compare valuation multiples, and identify listings that fit client mandates.

#### Valuation analysts

Create comparable-business datasets from asking prices, monthly earnings, margins, business age, and marketplace status.

#### Deal newsletters and research products

Schedule recurring runs and publish curated feeds of new or recently updated listings.

#### Data and automation teams

Send normalized marketplace records into a warehouse, CRM, spreadsheet, alerting service, or internal acquisition dashboard.

### Why use this Empire Flippers listings extractor?

- ✅ **Official public data route** — uses Empire Flippers' documented anonymous API.
- ✅ **Rich acquisition data** — financial, operational, traffic, trend, risk, and opportunity fields.
- ✅ **Useful filters** — price, profit, dates, niches, monetization, countries, status, and keywords.
- ✅ **Lookup mode** — track specific listing numbers while retaining the same filters.
- ✅ **Export-ready output** — stable field names and primitive arrays for common destinations.
- ✅ **Respectful retrieval** — no browser or proxy; requests remain below the documented rate limit.
- ✅ **Recurring monitoring** — sort by latest listing or update date for scheduled workflows.

### What data can you extract?

| Category | Example fields |
|---|---|
| Identity | `recordId`, `listingNumber`, `status`, `title`, `sourceUrl` |
| Asking economics | `priceUsd`, `listingMultiple`, `listingMultipleType`, `unpriced` |
| Monthly P&L | `monthlyNetProfitUsd`, `monthlyGrossRevenueUsd`, `monthlyExpensesUsd`, `profitMarginPercent` |
| Recurring revenue | `mrrUsd`, `churnPercent`, `growthPercent`, `ltvUsd`, `ltvCacRatio` |
| Trends | `netProfitTrendPercent`, `grossRevenueTrendPercent`, `uniqueUsersTrendPercent` |
| Classification | `niches`, `monetizations`, `customerType`, `countries` |
| Timeline | `firstMadeMoneyAt`, `firstListedAt`, `updatedAt`, `daysOnMarketplace` |
| Operations | `hoursWorkedPerWeek`, `workRequired`, `sellerSupport`, `dataProviders` |
| Diligence context | `opportunities`, `risks`, `reasonForSale`, `assetsIncluded` |
| Website metrics | `sitePlatforms`, page views, unique users, monthly financial and traffic JSON |
| Flags | trademark, PBN, new-listing, automated-sales, lender, and seller-call indicators |
| Provenance | `fetchedAt` and the public Empire Flippers listing URL |

Optional source values are omitted when Empire Flippers does not publish them for a listing.

### How much does it cost to scrape Empire Flippers listings?

The Actor uses pay-per-event pricing:

- **Actor start:** $0.005 per run.
- **Marketplace listing:** tiered by your Apify plan, with larger plans receiving lower per-listing prices.

The current per-listing prices are visible in the Apify Console before each run and are also defined in the Actor's pricing configuration.

A small 10-listing run is designed to be inexpensive, while one API page can return up to 100 listings efficiently.

Apify's free plan can be used for small evaluation runs within its available platform credits.

### How to scrape Empire Flippers in 5 steps

1. Open the Actor input page in Apify Console.
2. Keep **For Sale** selected or choose Pending Sold / Sold.
3. Set a small `maxItems` value for your first run.
4. Add financial, niche, monetization, country, or date filters if needed.
5. Click **Start** and export the resulting dataset as JSON, CSV, Excel, XML, or RSS.

For a deal monitor, schedule the Actor daily and sort by `last_updated` descending.

For a comps dataset, select Sold and choose a larger result limit.

### Input parameters

| Input | Type | Purpose |
|---|---|---|
| `maxItems` | integer | Maximum unique listings to save (1–5000) |
| `query` | string | Full-text listing search |
| `listingNumbers` | integer[] | Look up specific listing numbers |
| `listingStatus` | enum | For Sale, Pending Sold, or Sold |
| `minPrice`, `maxPrice` | number | Asking-price range in USD |
| `minMonthlyNetProfit`, `maxMonthlyNetProfit` | number | Monthly net-profit range in USD |
| `niches` | string[] | Exact source niche names |
| `monetizations` | string[] | Exact source monetization models |
| `countries` | string[] | Two-letter country codes |
| `usesPbn` | boolean | Filter by private-blog-network use |
| `hasTrademark` | boolean | Filter by trademark status |
| `hasSellerInterview` | boolean | Filter by interview availability |
| `sbaFinancingApproved` | boolean | Filter by SBA approval |
| `firstListedFrom`, `firstListedTo` | date | First-listing UTC date range |
| `updatedFrom`, `updatedTo` | date | Updated UTC date range |
| `sortBy` | enum | Source-side ordering field |
| `sortOrder` | enum | Ascending or descending |

Dates must use `YYYY-MM-DD`.

Use current source values such as `SaaS`, `eCommerce`, `Amazon FBA`, `Affiliate`, `Newsletter`, `Technology`, or `Health & Fitness`.

### Example inputs

#### Latest businesses for sale

```json
{
  "listingStatus": "For Sale",
  "maxItems": 20,
  "sortBy": "first_listed_at",
  "sortOrder": "DESC"
}
````

#### Profitable SaaS acquisition targets

```json
{
  "listingStatus": "For Sale",
  "monetizations": ["SaaS"],
  "minMonthlyNetProfit": 5000,
  "maxPrice": 2000000,
  "maxItems": 50,
  "sortBy": "average_monthly_net_profit",
  "sortOrder": "DESC"
}
```

#### Track known listings

```json
{
  "listingNumbers": [88274, 88123],
  "listingStatus": "For Sale",
  "maxItems": 2
}
```

The status filter still applies in listing-number mode, preventing an explicit lookup from bypassing the requested scope.

### Output example

```json
{
  "recordId": "1e7903e5-5596-4851-8645-a2778508ce8c",
  "listingNumber": 88274,
  "status": "For Sale",
  "title": "$318.7K Per Month eCommerce Business in the Lifestyle Niche",
  "priceUsd": 2877244,
  "monthlyNetProfitUsd": 75717,
  "monthlyGrossRevenueUsd": 318730,
  "monthlyExpensesUsd": 243013,
  "listingMultiple": 38,
  "listingMultipleType": "SDE",
  "profitMarginPercent": 24,
  "niches": ["Lifestyle", "Health & Fitness"],
  "monetizations": ["eCommerce"],
  "hoursWorkedPerWeek": 20,
  "daysOnMarketplace": 5,
  "sitePlatforms": ["Shopify"],
  "sourceUrl": "https://empireflippers.com/listing/88274/",
  "fetchedAt": "2026-07-19T03:00:00.000Z"
}
```

Values change as Empire Flippers updates its marketplace. The example demonstrates field shape, not a guaranteed current offer.

### Working with financial and traffic histories

`financialMetricsJson`, `trafficMetricsJson`, and `sitesJson` preserve detailed public monthly source records as JSON strings.

This design avoids nested dataset objects while retaining information needed for deeper analysis.

Parse these fields in your warehouse or automation tool when you need time-series metrics.

Use the flattened summary columns for spreadsheets and quick filters.

### Monitoring new listings and deal changes

Create an Apify schedule that runs daily with:

- `listingStatus: "For Sale"`
- `sortBy: "last_updated"`
- `sortOrder: "DESC"`
- a result cap appropriate for your monitoring window

Store listing number, status, price, and update timestamp in your destination.

Compare each run with the previous snapshot to detect:

- 🆕 newly listed businesses;
- 💵 asking-price changes;
- 🔄 movement to Pending Sold or Sold;
- 📈 changed revenue, profit, or trend values;
- 🧭 newly published opportunities, risks, or operational details.

### Tips for better results

- Start with 10–20 listings while refining filters.
- Use exact niche and monetization names from Empire Flippers.
- Use two-letter country codes such as `US`, `GB`, and `AU`.
- Sort by `first_listed_at` for new inventory.
- Sort by `last_updated` for repricing and status monitors.
- Request Sold listings when building historical comparables.
- Use listing-number mode for watchlists and CRM enrichment.
- Keep financial ranges logically ordered; invalid ranges fail before requests begin.

### Integrations

#### Google Sheets

Use the Apify Google Sheets integration to refresh a deal pipeline used by investment teams.

#### Webhooks and Slack

Trigger a webhook after successful runs, compare the dataset against prior records, and send high-fit opportunities to Slack.

#### Airtable or a CRM

Upsert by `listingNumber` so status and price updates modify the same acquisition record.

#### Data warehouses

Load JSON or CSV into BigQuery, Snowflake, PostgreSQL, or another analytical store for valuation and marketplace trend analysis.

#### Make and Zapier

Schedule a run, filter records by price or profit, and create notifications or review tasks without maintaining infrastructure.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/empire-flippers-marketplace-scraper').call({
  listingStatus: 'For Sale',
  monetizations: ['SaaS'],
  maxItems: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/empire-flippers-marketplace-scraper').call(run_input={
    'listingStatus': 'For Sale',
    'minMonthlyNetProfit': 5000,
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~empire-flippers-marketplace-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"listingStatus":"For Sale","maxItems":10}'
```

After the run finishes, fetch items from its `defaultDatasetId` through the Apify Dataset API.

### Use with Apify MCP and AI assistants

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/empire-flippers-marketplace-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/empire-flippers-marketplace-scraper"
    }
  }
}
```

Example prompts:

- “Find 20 current Empire Flippers SaaS listings under $2 million.”
- “Extract sold listings and compare asking-price multiples by niche.”
- “Check whether listing 88274 is still for sale and summarize its public risks.”
- “Build a table of monthly profit, workload, and valuation multiple for current ecommerce listings.”

### Rate limits and reliability

Empire Flippers documents a limit of no more than one Marketplace API request per second.

The Actor spaces requests slightly above one second globally.

Temporary HTTP 429 and server errors use bounded exponential backoff.

Each API page can return up to 100 listings, minimizing requests for normal workflows.

Malformed individual listings are skipped with a warning.

A missing response envelope or listings array fails the run instead of producing a misleading successful empty dataset.

### Limitations

- Only publicly visible Empire Flippers marketplace data is available.
- Seller identity, unlocked domains, diligence documents, and private account data are not extracted.
- Optional fields vary by business model and listing status.
- Listings may disappear from the public API for internal marketplace reasons.
- Source-defined niches, monetizations, statuses, and fields can change.
- This Actor reports public asking and operating data; it does not verify seller claims or provide investment advice.
- Large runs take longer because the source's one-request-per-second policy is intentionally respected.

### Is scraping Empire Flippers legal?

This Actor uses an official public Marketplace API that Empire Flippers documents for listing syndication and personal buyer use.

Users remain responsible for their own use case, contractual obligations, data retention, downstream communications, and compliance with applicable laws.

Do not use the output to misrepresent affiliation with Empire Flippers, expose private information, or make unsupported financial claims.

Review Empire Flippers' current API documentation and terms before production use.

### FAQ

#### Does this Actor require an Empire Flippers login?

No. The public Marketplace API currently requires no authentication.

#### Can it download diligence files or reveal seller identities?

No. Those are gated/private and intentionally outside the Actor's scope.

#### Why did my filter return zero listings?

The marketplace may have no public listing matching every selected condition. Remove filters one at a time, confirm exact niche/monetization spelling, and check the selected status.

#### Why was a requested listing number not returned?

The listing may no longer be public, may not match your selected status or financial filters, or may have been removed by the source.

#### Why does a large run take several seconds?

The Actor respects Empire Flippers' documented one-request-per-second limit. Up to 100 listings are collected per request.

#### Are numbers returned as numbers?

Yes. Prices, profit, revenue, expenses, multiples, workload, trends, and traffic summaries are normalized to numeric fields when the source value is parseable.

#### Can I run it on a schedule?

Yes. Use Apify Schedules and sort by first listing or last update date for recurring acquisition monitoring.

#### Does it use a proxy or browser?

No. The official anonymous JSON API is sufficient, which keeps runs fast and resource-efficient.

### Related scrapers

- [Flippa Listings Scraper](https://apify.com/automation-lab/flippa-listings-scraper) — monitor a separate online-business marketplace and broaden acquisition inventory.

Combine sources in your warehouse using source-specific listing identifiers and normalized financial columns.

### Support

If a run fails, include the run ID, input, expected listing or filter, and observed behavior in your support request.

Before reporting missing data:

1. Verify the listing remains public on Empire Flippers.
2. Check whether `listingStatus` excludes it.
3. Confirm exact niche, monetization, and country values.
4. Try a small broad run to distinguish a filter mismatch from a source outage.

Public API fields and availability are controlled by Empire Flippers and may evolve.

# Actor input Schema

## `maxItems` (type: `integer`):

Stop after this many unique marketplace listings.

## `query` (type: `string`):

Search public listing text, for example SaaS, pet, newsletter, or Shopify.

## `listingNumbers` (type: `array`):

Look up specific Empire Flippers listing numbers. Other filters below still apply.

## `listingStatus` (type: `string`):

Extract businesses currently for sale, pending sale, or already sold.

## `minPrice` (type: `number`):

Keep listings priced at or above this USD amount.

## `maxPrice` (type: `number`):

Keep listings priced at or below this USD amount.

## `minMonthlyNetProfit` (type: `number`):

Keep listings with at least this average monthly net profit.

## `maxMonthlyNetProfit` (type: `number`):

Keep listings with no more than this average monthly net profit.

## `niches` (type: `array`):

Exact Empire Flippers niche names, such as Health & Fitness, Technology, or Pet Care.

## `monetizations` (type: `array`):

Exact models such as SaaS, eCommerce, Amazon FBA, Affiliate, or Newsletter.

## `countries` (type: `array`):

Two-letter country codes separated as list entries, for example US, GB, or AU.

## `usesPbn` (type: `boolean`):

Filter listings by whether they use a PBN.

## `hasTrademark` (type: `boolean`):

Filter listings by published trademark status.

## `hasSellerInterview` (type: `boolean`):

Filter listings by seller-interview availability.

## `sbaFinancingApproved` (type: `boolean`):

Filter listings by published SBA financing approval.

## `firstListedFrom` (type: `string`):

Keep listings first published on or after this UTC date.

## `firstListedTo` (type: `string`):

Keep listings first published on or before this UTC date.

## `updatedFrom` (type: `string`):

Keep listings updated on or after this UTC date.

## `updatedTo` (type: `string`):

Keep listings updated on or before this UTC date.

## `sortBy` (type: `string`):

Choose the Empire Flippers field used to order results.

## `sortOrder` (type: `string`):

Return highest/newest first or lowest/oldest first.

## Actor input object example

```json
{
  "maxItems": 10,
  "listingStatus": "For Sale",
  "sortBy": "first_listed_at",
  "sortOrder": "DESC"
}
```

# Actor output Schema

## `listings` (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 = {
    "maxItems": 10,
    "listingStatus": "For Sale",
    "sortBy": "first_listed_at",
    "sortOrder": "DESC"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/empire-flippers-marketplace-scraper").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 = {
    "maxItems": 10,
    "listingStatus": "For Sale",
    "sortBy": "first_listed_at",
    "sortOrder": "DESC",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/empire-flippers-marketplace-scraper").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 '{
  "maxItems": 10,
  "listingStatus": "For Sale",
  "sortBy": "first_listed_at",
  "sortOrder": "DESC"
}' |
apify call automation-lab/empire-flippers-marketplace-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/empire-flippers-marketplace-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Empire Flippers Marketplace Scraper",
        "description": "Extract public Empire Flippers business listings with asking prices, monthly financials, valuation multiples, niches, workload, opportunities, risks, traffic, and status.",
        "version": "0.1",
        "x-build-id": "wLhhWRQScEtszjIqu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~empire-flippers-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-empire-flippers-marketplace-scraper",
                "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/automation-lab~empire-flippers-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-empire-flippers-marketplace-scraper",
                "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/automation-lab~empire-flippers-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-empire-flippers-marketplace-scraper",
                "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": {
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many unique marketplace listings.",
                        "default": 20
                    },
                    "query": {
                        "title": "Keyword search",
                        "type": "string",
                        "description": "Search public listing text, for example SaaS, pet, newsletter, or Shopify."
                    },
                    "listingNumbers": {
                        "title": "Listing numbers",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Look up specific Empire Flippers listing numbers. Other filters below still apply.",
                        "items": {
                            "type": "integer",
                            "minimum": 1
                        }
                    },
                    "listingStatus": {
                        "title": "Listing status",
                        "enum": [
                            "For Sale",
                            "Pending Sold",
                            "Sold"
                        ],
                        "type": "string",
                        "description": "Extract businesses currently for sale, pending sale, or already sold.",
                        "default": "For Sale"
                    },
                    "minPrice": {
                        "title": "Minimum asking price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Keep listings priced at or above this USD amount."
                    },
                    "maxPrice": {
                        "title": "Maximum asking price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Keep listings priced at or below this USD amount."
                    },
                    "minMonthlyNetProfit": {
                        "title": "Minimum monthly net profit (USD)",
                        "type": "number",
                        "description": "Keep listings with at least this average monthly net profit."
                    },
                    "maxMonthlyNetProfit": {
                        "title": "Maximum monthly net profit (USD)",
                        "type": "number",
                        "description": "Keep listings with no more than this average monthly net profit."
                    },
                    "niches": {
                        "title": "Niches",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Exact Empire Flippers niche names, such as Health & Fitness, Technology, or Pet Care.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "monetizations": {
                        "title": "Monetization models",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Exact models such as SaaS, eCommerce, Amazon FBA, Affiliate, or Newsletter.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Two-letter country codes separated as list entries, for example US, GB, or AU.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z]{2}$"
                        }
                    },
                    "usesPbn": {
                        "title": "Uses a private blog network",
                        "type": "boolean",
                        "description": "Filter listings by whether they use a PBN."
                    },
                    "hasTrademark": {
                        "title": "Has a trademark",
                        "type": "boolean",
                        "description": "Filter listings by published trademark status."
                    },
                    "hasSellerInterview": {
                        "title": "Has a seller interview",
                        "type": "boolean",
                        "description": "Filter listings by seller-interview availability."
                    },
                    "sbaFinancingApproved": {
                        "title": "SBA financing approved",
                        "type": "boolean",
                        "description": "Filter listings by published SBA financing approval."
                    },
                    "firstListedFrom": {
                        "title": "First listed from",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Keep listings first published on or after this UTC date."
                    },
                    "firstListedTo": {
                        "title": "First listed to",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Keep listings first published on or before this UTC date."
                    },
                    "updatedFrom": {
                        "title": "Updated from",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Keep listings updated on or after this UTC date."
                    },
                    "updatedTo": {
                        "title": "Updated to",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Keep listings updated on or before this UTC date."
                    },
                    "sortBy": {
                        "title": "Sort listings by",
                        "enum": [
                            "first_listed_at",
                            "last_updated",
                            "listing_price",
                            "average_monthly_net_profit",
                            "average_monthly_gross_revenue",
                            "listing_multiple",
                            "days_on_marketplace",
                            "listing_number"
                        ],
                        "type": "string",
                        "description": "Choose the Empire Flippers field used to order results.",
                        "default": "first_listed_at"
                    },
                    "sortOrder": {
                        "title": "Sort direction",
                        "enum": [
                            "DESC",
                            "ASC"
                        ],
                        "type": "string",
                        "description": "Return highest/newest first or lowest/oldest first.",
                        "default": "DESC"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
