# Empire Flippers Scraper - Listings & Valuations (`steadywren/empire-flippers-listings-scraper`) Actor

Empire Flippers scraper: find underpriced online businesses for sale. Every listing is rated against ~2,700 real sold deals of the same type and size, with fair value, typical days to sell, risk flags and new-listing alerts. Price, profit, revenue, multiples. $3 per 1,000 listings.

- **URL**: https://apify.com/steadywren/empire-flippers-listings-scraper.md
- **Developed by:** [Steadywren](https://apify.com/steadywren) (community)
- **Categories:** E-commerce, Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Empire Flippers Scraper - Listings & Valuations

Empire Flippers scraper to find underpriced online businesses and websites for sale: every Empire Flippers listing is rated **against ~2,700 real sold deals of the same type and size**, with a **fair value**, **how fast similar businesses sold**, a **stale-listing flag**, **risk flags** and **new-listing alerts** - plus price, monthly profit and revenue, multiple, age and trends. **$3 per 1,000 listings.**

![Empire Flippers Scraper - Listings & Valuations - example output](https://steadywren.com/assets/screens/empire-flippers-listings-scraper.png)

### What you get

- **Deal rating vs sold deals** (unique on the Store): each business for sale is compared by price-to-profit multiple with businesses of the same monetization (Amazon FBA, eCommerce, SaaS, content...) and size (monthly profit band) that actually sold on Empire Flippers. `below_market` = cheaper than 75% of them, `at_market` = middle half, `above_market` = priciest quarter, plus the exact percentile. Sold deals are loaded for free; you pay only for listings.
- **Fair value and negotiation signals**: `fairValueUsd` (profit x the multiple similar businesses sold at), `priceVsFairValuePct`, `typicalDaysToSell` for similar businesses, and `staleListing` when a listing has been on the market more than twice that long - room to negotiate.
- **Risk flags**: `profit_declining`, `thin_margin`, `owner_heavy`, `young_business`, `amazon_dependent` - computed from the listing's own numbers, so you can filter out risky deals in one step.
- **New-listing alerts**: turn on *Only new listings* and schedule the Actor daily - each run returns only businesses you have not seen yet (Google Sheets, Slack or email through Apify integrations).
- **Market report** for every run: per business type, listings, median price and multiple, the median multiple and days to sell of sold deals, and how many are below market or declining.
- **Clean numbers**: price, monthly net profit and revenue, margin, annual multiple, business age, hours per week, profit and revenue trends, and for SaaS: MRR, churn and LTV.
- **Reliable by design**: reads Empire Flippers' own listing data feed (no browser, no fragile HTML), and fails loudly instead of returning an empty "success" if the feed ever changes.

### Example result

```json
{
    "url": "https://empireflippers.com/listing/87338/",
    "listingId": "893b43ff-ac67-4f3d-86f1-4b9a75987b6e",
    "listingNumber": 87338,
    "status": "for_sale",
    "title": "$372.7K Per Month Amazon FBA Business in the Children Niche",
    "summary": "German Amazon FBA brand of children's swim accessories ... (seller's description, shortened here)",
    "monetizations": ["Amazon FBA"],
    "primaryMonetization": "Amazon FBA",
    "niches": ["Children", "Sports"],
    "country": "DE",
    "priceUsd": 1832339,
    "monthlyNetProfitUsd": 76347,
    "monthlyRevenueUsd": 372726,
    "profitMarginPct": 20,
    "annualProfitMultiple": 2,
    "businessAgeYears": 2.6,
    "hoursPerWeek": 10,
    "daysOnMarket": 338,
    "firstListedAt": "2025-11-27T17:00:01.635Z",
    "netProfitTrendPct": 43,
    "revenueTrendPct": 57,
    "trendMonths": 12,
    "mrrUsd": null,
    "churnPct": null,
    "ltvUsd": null,
    "valuationBasis": "Amazon FBA / $20k+/mo profit / sold since 2022",
    "soldCount": 31,
    "soldMedianMultiple": 3.5,
    "soldPercentile": 6,
    "dealRating": "below_market",
    "fairValueUsd": 3206574,
    "priceVsFairValuePct": -43,
    "typicalDaysToSell": 52,
    "staleListing": true,
    "riskFlags": ["amazon_dependent"],
    "isNew": null,
    "scrapedAt": "2026-11-02T00:43:39.840Z"
}
```

Reading it: this Amazon FBA brand asks 2x its annual profit ($1,832,339 / ($76,347 x 12)). The 31 Amazon FBA businesses with $20k+ monthly profit sold since 2022 were listed at a median 3.5x, and only 6% of them were as cheap - so it is rated below market, 43% under the fair value of $3.2M. Similar businesses sold in about 52 days; this one has been listed for 338, so the seller may negotiate.

### Market report

Each run also saves a `MARKET_REPORT` record (linked in the run's Output tab):

```json
{
    "generatedAt": "2026-11-02T00:43:40.000Z",
    "soldDealsLoaded": 2674,
    "soldDealsFailedRequests": { "blocked": 0, "rateLimit": 0, "network": 0, "parse": 0, "other": 0 },
    "valuationSkipped": null,
    "byMonetization": [
        {
            "monetization": "Amazon FBA",
            "listingsCount": 33,
            "medianPriceUsd": 809998,
            "medianProfitMultiple": 2.7,
            "belowMarketCount": 11,
            "profitDecliningCount": 6,
            "soldCount": 683,
            "soldMedianProfitMultiple": 2.67,
            "soldMedianDaysToSell": 46
        }
    ]
}
```

### How much does it cost?

You pay per listing: **1,000 listings cost $3**, plus a small Actor start fee charged by Apify. Platform compute is included, and the sold deals used for the rating are free. Empire Flippers has about 170-200 businesses for sale at a time, so a full run of every listing costs about $0.60 and takes about a minute (most of it loads the sold deals for the rating). Set **Max results** to cap your cost.

### Use cases

- **Acquisition scouting**: Amazon FBA or eCommerce businesses with $5k+ monthly profit, `below_market` and without `profit_declining`.
- **Negotiation**: compare a listing's price with `fairValueUsd` and use `staleListing` / `typicalDaysToSell` as leverage.
- **Deal alerts**: daily schedule with *Only new listings* into Google Sheets, Slack or your CRM.
- **Market research**: sold deals by type with their multiples and days on market (switch *Listings* to *Sold*).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `status` | `for_sale` / `pending_sold` / `sold` | `for_sale` | Businesses for sale, pending sales, or sold deals. Ratings are given to for-sale and pending listings. |
| `monetizations` | array | all | Amazon FBA, eCommerce, SaaS, Affiliate, Display Advertising, YouTube, Amazon KDP, Newsletter... A business matches when any of its monetizations is selected, so `primaryMonetization` can be another type. |
| `minPriceUsd` / `maxPriceUsd` | integer | - | Listing price range. |
| `minMonthlyProfitUsd` | integer | - | Minimum average monthly net profit. |
| `maxProfitMultiple` | number | - | Maximum price / annual net profit, e.g. `3.5`. |
| `maxItems` | integer | 200 | Stop after this many listings. Also caps your cost. |
| `includeValuation` | boolean | `true` | Deal rating, fair value, days to sell and stale flag against sold deals (free). |
| `onlyNew` | boolean | `false` | Return only listings your earlier runs (same *Listings* choice) have not returned. The first run returns everything. |
| `maxConcurrency` | integer | 3 | Parallel requests. |
| `proxyConfiguration` | object | Apify Proxy | Proxy settings; the default works. |

### Monitor daily

1. Console -> **Schedules** -> create a schedule for this Actor (or for a saved task with your filters) and let it run daily.
2. Turn on *Only new listings*: the first run returns everything, later runs only businesses you have not received yet (`isNew: true`). A day without new listings is a successful run with 0 results ("No new listings since the last run.").
3. Actor -> **Integrations**: send every finished run to Slack, email, Google Sheets or your own webhook.

### FAQ

**How is the deal rating calculated?** Multiple = price / (monthly net profit x 12), computed the same way for every listing. Comparables are sold deals with the same primary monetization (the first one listed) and profit band (<$1k, $1k-5k, $5k-20k, $20k+ per month). Deals listed since 2022 are used when there are at least 8 of them, otherwise all sold deals of that group; sizes are never mixed. `soldPercentile` is the share of comparable sold deals that were as cheap or cheaper; up to 25 = `below_market`, up to 75 = `at_market`, above = `above_market`. Listings without price or profit, or with fewer than 8 comparables (rare types with $20k+ monthly profit, for example), are not rated.

**Are sold prices the final sale prices?** No - Empire Flippers shows the last listing price of a sold business, not the negotiated price. The rating therefore answers "is this priced like businesses that actually sold?". For-sale and sold multiples are close on Empire Flippers (median about 30x monthly profit for both), so the comparison is meaningful.

**What do the risk flags mean?** `profit_declining`: net profit trend of -20% or worse; `thin_margin`: profit margin under 15%; `owner_heavy`: 30+ hours of work per week; `young_business`: under 2 years of revenue; `amazon_dependent`: any Amazon monetization (FBA, FBM, KDP, Associates, Merch).

**How does "Only new listings" work?** The Actor remembers the listings it returned in a key-value store named `empire-flippers-monitor` in your own Apify account, one list per *Listings* choice. Delete that store to start over.

**What if nothing matches my filters?** The run finishes successfully with 0 results and a message - widen the filters. You are not charged for listings, only the small start fee.

**Is it legal?** The Actor reads only public listing data that Empire Flippers shows to every visitor - no login, no seller or buyer personal data. Check Empire Flippers' terms for your use case.

**Something broke?** Open an issue on the Actor page - we answer within 12 hours.

### More from Steadywren

- [Flippa Scraper](https://apify.com/steadywren/flippa-listings-scraper) - businesses and websites for sale on Flippa, rated against similar listings for sale now, with sold-deal multiples and a market report.

**Who builds this?** [Steadywren](https://steadywren.com) - small tools, steady results. More products and custom builds on [steadywren.com](https://steadywren.com).

### Technical details

- Reads the public listing data feed behind empireflippers.com/marketplace (JSON, 200 listings per request), no browser.
- One request per selected business type, de-duplicated by listing id; price, profit and multiple filters are applied by the Actor.
- Retries: 403/429/5xx are retried with exponential backoff; 404 and other 4xx fail immediately.
- Every run stores a `RUN_SUMMARY` record (results, retries and failures per error category) and fails when it has 0 results (unless nothing matches your filters) or the key fields (`title`, `priceUsd`, `primaryMonetization`) are empty in most results.

# Actor input Schema

## `status` (type: `string`):

Businesses for sale (rated against sold deals), pending sales, or sold deals.

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

Leave empty for all types. A business matches when any of its monetizations is selected.

## `minPriceUsd` (type: `integer`):

Minimum listing price.

## `maxPriceUsd` (type: `integer`):

Maximum listing price.

## `minMonthlyProfitUsd` (type: `integer`):

Minimum average monthly net profit.

## `maxProfitMultiple` (type: `number`):

Maximum price / annual net profit (e.g. 3.5).

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

Stop after this many listings. You are charged per listing, so this also caps the cost.

## `includeValuation` (type: `boolean`):

Rate each business for sale against sold deals of the same type and size: deal rating, fair value, typical days to sell and a stale-listing flag. Sold deals are loaded for free.

## `onlyNew` (type: `boolean`):

Return only listings that earlier runs of yours (same Listings choice) have not returned yet. Use with a daily schedule for new-deal alerts. The first run returns everything.

## `maxConcurrency` (type: `integer`):

Parallel API requests.

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

Proxy servers used for the requests.

## Actor input object example

```json
{
  "status": "for_sale",
  "maxItems": 200,
  "includeValuation": true,
  "onlyNew": false,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped items as JSON. Add ?format=csv or ?format=xlsx for other formats.

## `runSummary` (type: `string`):

Items pushed, retries and failed requests per error category, and why the run failed if it did.

## `marketReport` (type: `string`):

Per business type: listings, median price and multiple, sold median multiple and days to sell, below-market and declining-profit counts.

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadywren/empire-flippers-listings-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 = { "proxyConfiguration": { "useApifyProxy": True } }

# Run the Actor and wait for it to finish
run = client.actor("steadywren/empire-flippers-listings-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call steadywren/empire-flippers-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steadywren/empire-flippers-listings-scraper"
        }
    }
}
```

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/8heFvT1evdAZi8zvj/builds/VNWUebHGC6Fdquj0z/openapi.json