# Flippa Scraper - Listings & Valuations (`steadywren/flippa-listings-scraper`) Actor

Flippa scraper: find underpriced businesses for sale. Every SaaS, ecommerce, content or app listing is rated below, at or above market against similar listings for sale now, plus the multiple similar ones sold at. Price, revenue, profit, multiples, verified data, market report. $1.50 per 1,000.

- **URL**: https://apify.com/steadywren/flippa-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 $1.50 / 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

## Flippa Scraper - Listings & Valuations

Flippa scraper to find underpriced online businesses and websites for sale: every Flippa listing gets a **deal rating against similar businesses for sale right now** (same type, industry and profit size) and the **prices similar businesses sold at** - plus price, monthly revenue and profit, multiple, age, type and industry. **$1.50 per 1,000 listings.**

![Flippa Scraper - Listings & Valuations - example output](https://steadywren.com/assets/screens/flippa-listings-scraper.png)

### What you get

- **Deal rating** (unique on the Store): each business for sale is compared by price-to-profit multiple with similar businesses on sale now - same type, industry and size (monthly profit band). `below_market` = in the cheapest quarter, `at_market` = middle half, `above_market` = priciest quarter, plus the exact percentile.
- **Sold-deal reference**: the median multiple at which similar businesses sold and how far the asking price is above it - your anchor for negotiating. Comparables are loaded for free; you pay only for listings.
- **Market report** for every run: per business type, the number of listings, median price and multiple, the median multiple of sold deals, share of reduced and verified listings, and how many are below market.
- **Deal metrics, ready for analysis**: price, monthly revenue, monthly profit and profit multiple as plain numbers (USD), plus business age, type, industry and location.
- **Sold deals**: switch to *Sold* to export what SaaS, ecommerce, content or app businesses went for - including auction results and bid counts.
- **Trust signals**: whether the listing is data-verified, which sources are connected (Stripe, Shopify, Google Analytics, PayPal, Amazon Seller...), and who lists it (Flippa broker, partner broker or owner).
- **Fails loudly, never silently**: if Flippa changes its layout, the run fails instead of returning an empty "success", so you never pay for garbage.

### Example result

```json
{
    "url": "https://flippa.com/14144546-high-ticket-solar-off-grid-wellness-reseller-2-8k-aov-1-000-orders-160-suppliers-no-inventory-10-20-hrs-wk-growing-since-2024",
    "listingId": "14144546",
    "status": "open",
    "headline": "Ecommerce | Home and Garden",
    "summary": "High Ticket Solar, Off-Grid & Wellness Reseller | $2.8K AOV | 1,000+ Orders | 160+ Suppliers | No Inventory | 10–20 Hrs/Wk | Growing Since 2024",
    "propertyType": "Ecommerce",
    "industry": "Home and Garden",
    "location": "OH, United States",
    "saleMethod": "classified",
    "priceUsd": 750000,
    "originalPriceUsd": null,
    "priceReducedPct": null,
    "bidCount": null,
    "equityForSalePct": null,
    "monthlyRevenueUsd": 327000,
    "monthlyProfitUsd": 22600,
    "profitMultiple": 2.8,
    "ageYears": 2,
    "listedBy": "flippa_broker",
    "dataVerified": true,
    "verifiedIntegrations": ["Google Analytics", "Shopify"],
    "valuationBasis": "Ecommerce / $20k+/mo profit",
    "peerCount": 11,
    "peerMedianMultiple": 2.34,
    "peerPercentile": 73,
    "dealRating": "at_market",
    "soldCount": null,
    "soldMedianMultiple": null,
    "soldValueUsd": null,
    "priceVsSoldPct": null,
    "scrapedAt": "2026-11-02T00:00:00.000Z"
}
```

Reading it: this store asks about 2.8x its annual profit ($750,000 / ($22,600 x 12)); similar ecommerce businesses with $20k+ monthly profit for sale now ask a median 2.34x, and it is pricier than 73% of them - priced at market. When enough similar sold deals exist, `soldMedianMultiple` shows what they sold at.

### Market report

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

```json
{
    "generatedAt": "2026-11-02T00:00:00.000Z",
    "peerListingsLoaded": 500,
    "soldDealsLoaded": 500,
    "valuationSkipped": null,
    "byType": [
        {
            "propertyType": "SaaS",
            "listingsCount": 100,
            "medianPriceUsd": 139639,
            "medianProfitMultiple": 3.28,
            "reducedPricePct": 37,
            "dataVerifiedPct": 70,
            "soldCount": 77,
            "soldMedianProfitMultiple": 0.95,
            "belowMarketCount": 15
        }
    ]
}
```

If no comparables can be loaded, listings are still returned, `valuationSkipped` explains why and the valuation fields stay `null`.

### How much does it cost?

You pay per listing. **1,000 listings cost $1.50**, plus a small Actor start fee charged by Apify. Platform compute is included. One search page returns 50 listings in about a second; with the deal rating on, a run first loads the comparables (about 20 pages, free for you), so a typical run takes under a minute. Set **Max results** to cap your cost.

### Use cases

- **Acquisition scouting**: SaaS under $50k with at least $1k monthly profit, sorted by `peerPercentile` to see the cheapest relative to similar businesses first.
- **Valuation**: pull sold deals in your category to see real price-to-profit multiples.
- **Market research**: how many ecommerce stores in Health and Beauty are for sale, at what prices, and how often prices get reduced.
- **Deal alerts**: schedule the Actor daily with your filters and get the matching listings with their deal rating into Google Sheets, Slack or your CRM through Apify integrations (see "Monitor daily").

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `status` | `open` / `sold` | `open` | Businesses for sale, or sold deals. |
| `propertyTypes` | array | all | Ecommerce, SaaS, content, YouTube, Amazon FBA/KDP, apps, agencies, newsletters, domains... |
| `industries` | array | all | Business, Internet, Health and beauty, Home and garden... |
| `minAskingPriceUsd` / `maxAskingPriceUsd` | integer | - | Asking price range. |
| `minMonthlyProfitUsd` | integer | - | Minimum monthly net profit. |
| `minMonthlyRevenueUsd` | integer | - | Minimum monthly revenue. |
| `maxProfitMultiple` | integer | - | Maximum price-to-annual-profit multiple. |
| `maxItems` | integer | 100 | Stop after this many listings. Also caps your cost. |
| `includeValuation` | boolean | `true` | Deal rating against similar listings for sale + sold-deal reference (comparables are not charged). |
| `compsMaxItems` | integer | 500 | How many comparable listings for sale, and how many sold deals, to load (50 per page each). |
| `startUrls` | array | - | Optional: your own flippa.com/search URLs (filters above are then ignored; comparables use the types and industries of all your for-sale URLs, and their minimum monthly profit when every URL has one). |
| `maxConcurrency` | integer | 5 | Search pages fetched in parallel. |
| `proxyConfiguration` | object | Apify Proxy | Proxy settings; the default works for Flippa. |

### 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. Each run returns every listing that matches your filters, with a fresh deal rating and `MARKET_REPORT`. To see only new ones, compare `listingId` with the previous run (for example in Google Sheets); to see only bargains, filter on `dealRating: below_market`.
3. Actor -> **Integrations**: send every finished run to Slack, email, Google Sheets or your own webhook.

### FAQ

**Which fields can be empty?** Pre-revenue businesses show revenue and profit as `null` (Flippa displays "N/A"). Partial sales ("50% equity") have no price but `equityForSalePct` set. Auctions have `saleMethod: "auction"`, the current or winning bid in `priceUsd` and `bidCount`.

**How is the deal rating calculated?** Multiple = price / (monthly profit x 12), computed the same way for every listing. Comparables are listings of the same type and profit band (<$1k, $1k-5k, $5k-20k, $20k+ per month), and of the same industry when there are at least 8 of them; otherwise type and band only; never mixed sizes. `peerPercentile` is the share of comparable listings for sale that are as cheap or cheaper; up to 25 = `below_market`, up to 75 = `at_market`, above = `above_market`. Listings without a business type, profit or price, partial sales, or with fewer than 8 comparables are not rated.

**Why does `profitMultiple` sometimes differ from the rating's multiple?** `profitMultiple` is the multiple exactly as Flippa displays it; for some listings Flippa uses a different profit period. The deal rating always uses its own multiple (price / (monthly profit x 12)), so every listing is compared the same way.

**Why is the `headline` sometimes just "SaaS | Internet"?** Many sellers list confidentially, and Flippa then shows the business type and industry instead of a name. The seller's description is always in `summary`.

**Why not rate against sold deals?** Flippa shows the last listed price of a sold business (often after several reductions) and does not publish final negotiated prices of fixed-price sales, so sold multiples sit far below asking multiples for every size. They are shown as a negotiation reference (`soldMedianMultiple`, `priceVsSoldPct`), not used for the rating.

**What if nothing matches my filters?** The run finishes successfully with 0 results and the message "No listings match your filters" - widen the types, price or profit filters. You are not charged for listings, only the small start fee.

**Is it legal?** The Actor reads only public search pages - no login, no private messages, and no seller personal data (broker and owner names are not collected). Check Flippa's terms for your use case.

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

### More from Steadywren

- [Empire Flippers Scraper](https://apify.com/steadywren/empire-flippers-listings-scraper) - businesses for sale on Empire Flippers, rated against ~2,700 sold deals, with fair value, risk flags and new-listing alerts.

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

### Technical details

- Plain HTTP + Cheerio on Flippa's server-rendered search pages (50 listings per page), no browser.
- Prices shown by Flippa in USD; `K`/`M` amounts are converted to whole numbers.
- Retries: 403/429/5xx are retried with exponential backoff; 404 and other 4xx fail immediately; real challenge pages count as blocked.
- Every run stores a `RUN_SUMMARY` record (results, retries and failures per error category) and fails when it has 0 results (unless Flippa itself reports no matches for your filters) or the key fields (`headline`, `priceUsd`, `propertyType`) are empty in most results.

# Actor input Schema

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

Businesses currently for sale, or sold deals (useful as valuation comparables).

## `propertyTypes` (type: `array`):

Leave empty for all types.

## `industries` (type: `array`):

Leave empty for all industries.

## `minAskingPriceUsd` (type: `integer`):

Minimum asking price.

## `maxAskingPriceUsd` (type: `integer`):

Maximum asking price.

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

Minimum monthly net profit.

## `minMonthlyRevenueUsd` (type: `integer`):

Minimum monthly revenue.

## `maxProfitMultiple` (type: `integer`):

Maximum asking price / annual profit multiple (whole number, e.g. 3).

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

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

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

For businesses for sale: rate each price-to-profit multiple against comparable businesses for sale right now (same type, industry and profit size) and show what similar businesses sold for. Adds dealRating, peerPercentile, peerMedianMultiple, soldMedianMultiple and more. Comparables are not charged.

## `compsMaxItems` (type: `integer`):

How many comparable listings for sale, and how many sold deals, to load (50 per page each). More comparables give more listings a rating.

## `startUrls` (type: `array`):

Paste search URLs from flippa.com/search with your own filters. When set, the filters above are ignored.

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

Search pages fetched in parallel.

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

Proxy servers used for the requests.

## Actor input object example

```json
{
  "status": "open",
  "maxItems": 100,
  "includeValuation": true,
  "compsMaxItems": 500,
  "maxConcurrency": 5,
  "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-deal median multiple, share of reduced and verified listings, deals below market.

# 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/flippa-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/flippa-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/flippa-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steadywren/flippa-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/ZHK84fpBQ74tfFHDX/builds/a0YQ3c12sP9Hwh9BO/openapi.json