# Flippa Scraper: Businesses for Sale, Sold Comps & Multiples (`oswaldocarabano/flippa-businesses-for-sale-scraper`) Actor

Scrape Flippa businesses for sale: asking price, monthly revenue and profit, profit and revenue multiples, age, traffic, MRR, churn, verification and broker data. Sold comparables and category snapshots with median multiples. Filter by type, industry, country, price, profit. No login.

- **URL**: https://apify.com/oswaldocarabano/flippa-businesses-for-sale-scraper.md
- **Developed by:** [Oswaldo Carabano](https://apify.com/oswaldocarabano) (community)
- **Categories:** Business, Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 business for sales

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/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 — Businesses for Sale, Sold Comps & Valuation Multiples

Extract **online businesses for sale from Flippa** with everything their public listing page shows: asking price (and the price before a reduction), **monthly revenue and profit, profit margin, profit and revenue multiples**, business age, location, traffic, MRR, subscribers, churn, app ratings and downloads, data verification (Google Analytics, Stripe), Flippa vetting, the broker's track record, views and watchers. Get **recently sold businesses** as comparables (with the final price of sold auctions) and **category snapshots**: one row per business type or industry with median asking price, median profit multiple, revenue and margin, and an opportunity score.

No login, no account, no API key. Duplicate rows within a run and error rows are **never charged**.

> This actor is not affiliated with, endorsed by, or connected to Flippa. It reads public pages only.

### What you get

| Output type | One row per | Highlights |
|---|---|---|
| `listings` (default) | business for sale matching your filters | 104 columns, **about 51 filled per listing** (n = 6,081, 17 Oct 2026): asking price, original price and reduction, seller currency and exchange rate, monthly revenue and profit, margin, profit and revenue multiples, age and approximate founding date, location, sale method, bids, reserve and time left for auctions, page views, MRR, subscribers, churn, app rating/reviews/downloads, followers, domain data, newsletter rates, verification and vetting, broker company and track record, payment methods, views, watchers, comments, full "About the business" text |
| `listing-details` | Flippa link you paste | The same row for specific listings |
| `sold` | recently sold business | The same fields, the last asking price and, for sold auctions, the **final price** — valuation comparables |
| `category-snapshot` | business type or industry | Listings scanned and Flippa's total, median and quartile asking price, median and quartile profit multiple, median revenue multiple, median monthly revenue and profit, median margin and age, shares of verified, auction, price-reduced and brokered listings, top industries/types/countries, **opportunity score** |

### Filters

All filters can be combined: **business type** (18 Flippa categories, domains optional), **industry** (15), **seller location** (country codes or regions), **asking price**, **monthly profit**, **monthly revenue**, **age**, **sale method** (auction / classified), **listed by** (Flippa broker, partner broker, owner), **keyword**, **profit multiple**, **revenue multiple**, **only listings with connected data**, and **sort order**.

Flippa applies most filters itself, and the actor **re-checks every result** against your filters: a listing whose shown value breaks a filter is skipped without charge. Flippa's own multiple filters do not match the multiples it displays (measured on 17 Oct 2026: with "multiple at least 4", 88% of the results showed less), so **profit and revenue multiples are checked by the actor** on each search result before the listing page is opened; a run checks up to 100 search results per requested row (at least 2,000, at most 12,000) and says so in the status when it stops early.

Pasting listing links with the default output type runs `listing-details` for exactly those; filters are not applied to pasted links.

Keywords are plain words. Flippa's firewall refuses some searches that look like code or database commands (for example "union select"); the actor checks the same search without the keyword, and if that works it stops at once with an `invalid-input` row that is not charged, instead of retrying.

### Data quality, measured

Measured with this actor on 17 Oct 2026: **every business for sale in the 18 business types (6,081 listings, one full run on the Apify platform, 0 duplicates, 0 error rows)** and every recently sold one listed by Flippa (1,115 sold listings, one full run on the Apify platform on 21 Oct 2026). "Filled" = not null and not empty.

| Field | For sale (n = 6,081) | Sold (n = 1,115) |
|---|---:|---:|
| Asking price, age, location, business type, industry, views, watchers | 100% | 100% |
| Monthly profit | 61% | 72% |
| Monthly revenue | 58% | 70% |
| Profit margin | 45% | 61% |
| Profit multiple · revenue multiple | 45% · 45% | 59% · 55% |
| Final price of sold auctions | — | 40% |
| "About the business" text | 68% | 31% |
| Flippa vetting label | 49% | 47% |
| Connected data (Google Analytics, Stripe…) | 38% | 35% |
| Page views per month | 19% | 21% |
| Broker name and track record | 10% | 7% |
| App Store rating and reviews (apps) | 6% of all listings | 6% |

Filled fields per listing: **average 50.7 of 104** (p10 40, median 52, p90 60; n = 6,081); sold: 51.1 (p10 41, median 53, p90 58; n = 1,115). The full run took 32 minutes for 6,081 listings with their pages.

Flippa keeps the monthly P\&L, detailed traffic and seller notes behind an account; this actor never logs in, so those are not included (`detailsLocked: true`). Newer and smaller listings often omit revenue; broker-managed listings are the most complete.

### How it compares

Compared with the other Flippa actors in the Store as declared in their own schemas, inputs and READMEs (17 Oct 2026):

| | This actor | Market leader | Other Flippa actors |
|---|---|---|---|
| Price per listing | **$0.001** | $0.001 | $0.0005–$0.016 |
| Start fee | **$0.00001** | $0.007 | up to $0.20 |
| Needs your Flippa login for financials | **never** | asks for email, password or cookies | — |
| Sold businesses with final auction price | **yes** | not declared | 2 small actors |
| Category snapshot with median multiples | **yes** | no | no |
| Multiple filters that match the shown multiple | **yes** | — | rely on Flippa's filter |
| Error rows charged | **never** | — | often (charged as dataset items) |
| Successful runs | 50 of 50 test runs, plus 39 of 39 confirmation runs and an independent review (Oct 2026) | 87.8% (361 of 411, last 30 days) | — |

### Pricing

Pay per event — you pay only for rows delivered:

| Event | Price |
|---|---|
| Business for sale (`listings`, `listing-details`) | **$0.001** ($1.00 per 1,000) |
| Sold business (`sold`) | $0.001 |
| Category snapshot (one business type or industry) | $0.01 |
| Actor start | $0.00001 |

Duplicates within a run, listings skipped by your filters, and error rows (not found, unavailable) are **never charged**. Rows reused from the shared cache cost the same as live rows and carry `cachedAt`. If you set a maximum cost per run, the actor stops cleanly when it is reached.

### Opportunity score

Every `category-snapshot` row carries `opportunityScore` (0–100) and its four components, computed with a fixed, published formula — the same in every run and comparable between runs:

- **Demand (40%)**: `min(1, log10(1 + total monthly revenue of the group in USD) / 8)` — 8 means $100M of monthly revenue listed in the group.
- **Dissatisfaction (25%)**: share of items rated below 4 stars — **not measurable on Flippa** (listings have no ratings): its component is `null` and `dissatisfactionMeasured` is `false`.
- **Staleness (20%)**: share of items not updated in two years — **not measurable on Flippa** (publication dates are not public): its component is `null` and `stalenessMeasured` is `false`. Components that cannot be measured are left out and the score is divided by the weights that remain.
- **Openness (15%)**: `1 / (1 + populationCount / 50)` — fewer listings means a less crowded market. `populationCount` is the group's real size on Flippa (its own count for your filters), so the score does not depend on how many rows you asked for; when Flippa only shows a cap ("10,000+", domains) the scanned count is used and `opennessBasis` says `sample` instead of `category`. Formula version `v1.4` (in `opportunityFormula`).

With the multiple or verification filters, which the actor applies itself, `populationCount` is the number of listings that match them when the whole group was scanned (`scanComplete: true`).

`medianDemand` (the shared module's median of the demand signal) is the median monthly revenue of the listings that **show** one — listings without a published revenue are left out, not counted as $0 — so it equals `medianMonthlyRevenueUsd`; `demandKnownCount` says how many listings it covers.

So on Flippa the score is `(0.40 × demand + 0.15 × openness) / 0.55`, from 0 to 100 (measured on 22 Oct 2026: 46.5–70.4 across the 18 business types, 58.8–67.0 across the 15 industries), and ranks groups by listed revenue against crowding. Use it with the medians next to it: a group with high median revenue and a low median profit multiple is where businesses sell cheaply relative to what they earn.

### Input examples

Default input `{}`: 20 listings in 4–7 seconds (measured on 17 Oct 2026, on the Apify platform, with listing pages from the shared cache; about 18 seconds fully live): the 20 newest businesses for sale with their listing pages. A market snapshot of every business type (about 6,080 listings scanned) takes about 1 minute; 300 listings with their pages, fetched live, about 2 minutes.

Profitable SaaS for sale under $100,000 at most 3x yearly profit:

```json
{
  "propertyTypes": ["saas"],
  "maxPrice": 100000,
  "minMonthlyProfit": 1000,
  "maxProfitMultiple": 3,
  "maxItems": 100
}
```

US ecommerce businesses with connected data, sold recently (comparables):

```json
{ "outputType": "sold", "propertyTypes": ["ecommerce"], "countries": ["us"], "dataVerifiedOnly": true, "maxItems": 200 }
```

Market snapshot by industry:

```json
{ "outputType": "category-snapshot", "snapshotGroupBy": "industry" }
```

Specific listings:

```json
{ "listingUrls": ["https://flippa.com/12000168", "11816135"] }
```

### Output

One row type per run in the default dataset, with views for an overview, financials and valuation, traffic and apps, auctions, snapshots and errors. All money fields are in USD (`currency: "USD"`), the seller's own currency is kept next to them, dates are ISO 8601, and missing values are explicit `null`. The run also writes `ERRORS` (always present, empty when nothing failed) and `RUN_SUMMARY` (delivered, charged, duplicates, filtered, errors) to the key-value store.

Example (shortened):

```json
{
  "_type": "listing",
  "id": "12000168",
  "url": "https://flippa.com/12000168-turnkey-ai-saas-with-12-3k-annual-revenue-71-margins-540-subscribers-0-churn-ios-android-apps-and-strong-growth-potential",
  "propertyType": "SaaS",
  "industry": "Internet",
  "country": "United Arab Emirates",
  "askingPriceUsd": 9999,
  "originalPriceUsd": 21740,
  "priceReducedPct": 54,
  "monthlyProfitUsd": 499,
  "profitMarginPct": 72,
  "profitMultiple": 1.7,
  "revenueMultiple": 1.2,
  "pageViewsPerMonth": 1511,
  "activeSubscribers": 546,
  "churnPct": 2,
  "integrations": ["Google Analytics", "Stripe"],
  "ageMonths": 24,
  "watchers": 311
}
```

### Reliability

- Requests are paced per connection and spread across connections; a temporary block switches to a fresh connection at once (never the same one again), and long blocks pause briefly. Verification pages are never solved: the actor simply uses another connection.
- If something cannot be fetched, you get an explanatory error row that is **not charged**, and the run still finishes successfully. If a listing page cannot be read, the row still carries the search-result fields (`detailFetched: false`).
- Runs survive platform migrations without duplicating or re-charging rows.
- If Flippa changes its page format, the actor refuses to guess and returns a `schema-changed` error row instead of empty data.

### Privacy

The actor returns only what Flippa publishes on public pages. Owners' identities are not shown by Flippa without an account, and are not returned. For brokers it returns their public professional profile (name, company, country, short bio, feedback and transaction totals). E-mail addresses and phone numbers are removed from every text and name. You are responsible for using the data in line with applicable law (e.g. GDPR) and Flippa's terms.

### FAQ

**Does it need a Flippa account?** No. It reads public pages only, so the monthly P\&L and seller notes that Flippa keeps behind an account are not included.

**How fresh is the data?** Search results are always live. Listing pages fetched by any run in the last 12 hours are reused from a shared cache (rows carry `cachedAt`; same price). Set `maxCacheAgeHours` to 0 to read every listing page live.

**How many listings are there?** About 6,080 businesses for sale across the 18 business types, plus 10,000+ domains, and about 1,120 recently sold (17 Oct 2026).

**Why is monthly revenue rounded?** Flippa's search results show revenue rounded to three significant digits (e.g. $160K); `monthlyRevenueApprox` says so. Monthly profit comes exact from the listing page, in the seller's currency and in USD.

# Actor input Schema

## `outputType` (type: `string`):

One row type per run. <b>listings</b>: online businesses for sale that match your filters, each with its public listing page (about 50 filled fields per row: asking price, monthly revenue and profit, margins, profit and revenue multiples, age, traffic, MRR, churn, app downloads, verification, broker track record, views and watchers). <b>listing-details</b>: the same row for the Flippa links you paste. <b>sold</b>: recently sold businesses (comparables) with their last asking price, and the final price of auctions. <b>category-snapshot</b>: one row per business type or industry with medians of price, revenue, profit and multiples plus an opportunity score.

## `listingUrls` (type: `array`):

Flippa listing pages, for example https://flippa.com/12000168-turnkey-ai-saas…, or just the listing id (12000168). Only the id is read from each entry. Pasting links with the type "Businesses for sale" switches the run to listing details; filters are not applied to pasted links. Entries that are not Flippa listing links get one error row that is not charged.

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

Rows delivered (and charged) at most. Duplicates and error rows are never charged. About 6,080 businesses are for sale and about 1,120 sold ones are listed (17 Oct 2026). When you paste listing links and leave this empty, every one of them is delivered.

## `includeDetails` (type: `boolean`):

On (recommended): each row adds the public listing page — exact monthly profit in the seller's currency, profit margin, revenue multiple, traffic, MRR, subscribers, churn, app rating and downloads, the "About the business" text, Flippa vetting, broker track record, payment methods, views and watchers. Off: search-result fields only (about 30), several times faster.

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

Only these Flippa business types. Empty = every business type except domains (domains are a separate market of 10,000+ listings; pick "Domains" to include them).

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

Only these Flippa industries (verticals).

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

Two-letter country codes of the business location (us, gb, ca, au…) or regions: nam (North America), weu (Western Europe), eeu (Eastern Europe), asi (Asia), oce (Oceania), sam (South America), afr (Africa). 2,296 of 6,083 open listings are in the US.

## `keyword` (type: `string`):

Flippa keyword search over titles and descriptions (for example "dating", "AI writing", "pet"). Letters, digits, spaces and simple punctuation only.

## `minPrice` (type: `integer`):

Asking price, or current bid for auctions.

## `maxPrice` (type: `integer`):

Asking price, or current bid for auctions.

## `minMonthlyProfit` (type: `integer`):

Net profit per month as listed.

## `maxMonthlyProfit` (type: `integer`):

Net profit per month as listed.

## `minMonthlyRevenue` (type: `integer`):

Revenue per month as listed.

## `maxMonthlyRevenue` (type: `integer`):

Revenue per month as listed.

## `minProfitMultiple` (type: `number`):

Asking price divided by the last 12 months of profit, as shown on Flippa (e.g. 2.5). Checked by the actor on each search result (Flippa's own multiple filter does not match the shown multiple); results without a multiple are skipped. A run checks up to 100 search results per requested row.

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

For example 3 = at most 3x yearly profit. Checked by the actor; see the min field.

## `minRevenueMultiple` (type: `number`):

Asking price divided by 12 × monthly revenue. Checked by the actor on each search result.

## `maxRevenueMultiple` (type: `number`):

For example 1 = priced at most at one year of revenue. Checked by the actor.

## `minAgeYears` (type: `number`):

Business age as shown on Flippa (for example 3).

## `maxAgeYears` (type: `number`):

For example 1 = businesses up to one year old.

## `saleMethod` (type: `string`):

Auctions (current bid, bids, time left, reserve) or classifieds (fixed asking price).

## `managedBy` (type: `array`):

Flippa brokers, partner brokers or the owners themselves (about 90% of listings).

## `dataVerifiedOnly` (type: `boolean`):

Keep only listings whose seller connected Google Analytics, Stripe or another data source (shown as "Data Verified" on Flippa). Checked by the actor on each search result.

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

Flippa's own ordering of the results.

## `snapshotGroupBy` (type: `string`):

For category-snapshot: one row per business type or per industry.

## `maxCacheAgeHours` (type: `integer`):

Listing pages fetched by any run in the last N hours are reused (rows say when, in cachedAt). 0 = always live. Search results are always live.

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

Listing pages fetched at the same time. 6 is fast and gentle; higher values finish large runs sooner.

## Actor input object example

```json
{
  "outputType": "listings",
  "listingUrls": [],
  "maxItems": 20,
  "includeDetails": true,
  "propertyTypes": [],
  "industries": [],
  "countries": [],
  "saleMethod": "any",
  "managedBy": [],
  "dataVerifiedOnly": false,
  "sortBy": "newest",
  "snapshotGroupBy": "propertyType",
  "maxCacheAgeHours": 12,
  "maxConcurrency": 6
}
```

# Actor output Schema

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

The rows of this run: businesses for sale, sold comparables or category snapshots, depending on the outputType you chose.

## `errors` (type: `string`):

Every error of the run with its reason and what to do. Always present, empty when nothing failed.

## `summary` (type: `string`):

Counts of delivered, charged, duplicate, filtered and error rows for this run.

# 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": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("oswaldocarabano/flippa-businesses-for-sale-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": 20 }

# Run the Actor and wait for it to finish
run = client.actor("oswaldocarabano/flippa-businesses-for-sale-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 '{
  "maxItems": 20
}' |
apify call oswaldocarabano/flippa-businesses-for-sale-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,oswaldocarabano/flippa-businesses-for-sale-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/xR5aRQpFyMfCckhpO/builds/FVgROcdEPAOD3YoCX/openapi.json