# Flippa Scraper - Online Businesses & Websites For Sale (`scrapyx/flippa-listings-scraper`) Actor

Scrapes Flippa's public API for online businesses for sale: websites, e-commerce stores, SaaS, Amazon FBA, apps and domains. Returns asking price, monthly revenue and profit, traffic, verification flags, auction state and seller location, with honest reporting of Flippa's 10,000 total clamp.

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

## Pricing

from $2.10 / 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.
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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Flippa Scraper — Online Businesses & Websites For Sale

Every listing on **Flippa**, the largest marketplace for buying and selling
online businesses: e-commerce stores, content sites, SaaS, Amazon FBA
storefronts, iOS and Android apps, and domains.

Asking price, monthly revenue and profit, traffic, verification flags, auction
state and seller location. No API key, no login.

***

### What you get

Three record types share one dataset, told apart by `recordType`:

- **`LISTING`** — title and summary, the Flippa URL, `propertyType`, `price`,
  `status` and `saleMethod`, the financials Flippa surfaces (`ttm_revenue`,
  `revenue_multiple`, `profit_average`, `multiple`, `monetization`), auction
  state (`bid_count`, `end_at`), when it was established, the country and
  primary platform, the verification flags, and a thumbnail. Flippa's own field
  names are passed through verbatim, so any field it adds appears without an
  actor update.
- **`SEARCH_SUMMARY`** — one per run: filters applied, upstream's total and
  whether it is exact, pages and requests made, rate-limit hits.
- **`ERROR`** — one per failed run, so **every run produces at least one row**.

Every row carries `_input`, `_source`, `_scrapedAt`, `recordType`.

#### Financials are seller-reported — and the flags say when they aren't

`revenuePerMonth` and `profitPerMonth` are whatever the seller entered.
Flippa separately verifies some listings, so **`hasVerifiedRevenue`** and
**`hasVerifiedTraffic`** travel beside those numbers on every row and are never
null — "unverified" is a real state, not missing data. On a sample of 100
listings, 5 carried verified revenue. Filter on those flags before treating any
of it as fact.

***

### Two things worth knowing before you read the numbers

**The total clamps at 10,000.** Below that it is a real count and paging ends
exactly on it — `website` reports 4,627, `fba` 281, `ios_app` 247. At 10,000 it
is a floor, not a count: a very broad category such as `domain` reports exactly
10,000. **`totalIsExact`** tells you which case you are in. Narrow by type or
price to get a real count.

**`propertyTypes` are categories, not row types.** `website` covers several
display types, so asking for it returns rows whose `propertyType` reads
`Ecommerce`, `Content`, `SaaS`, `Marketplace`, `Service` or `Marketing Agency`.
That is correct, not a broken filter. The summary row carries both
`displayTypesExpected` and `displayTypesSeen` so you can check the filter bound
without knowing Flippa's taxonomy.

**An empty result stays empty.** If a query matches nothing, Flippa's page
shows a "you might like" promo strip; the actor recognises that (the reported
total is 0) and returns no `LISTING` rows for it, rather than passing the promo
listings off as matches.

***

### Speed and the proxy

The `/search` page the actor reads is only lightly rate-limited — a burst of
requests from one IP comes back fine — so runs are fast even without a proxy.

The Apify residential proxy (**on by default**) takes a fresh exit IP per
request, which removes any limit you might hit on a very large run; turning it
off simply paces a little more conservatively. `rateLimitHits` on the summary
row tells you whether a limit was ever met (it is normally 0).

***

### Input

| Field | Meaning |
|---|---|
| `propertyTypes` | Flippa's six categories: `website`, `fba`, `ios_app`, `android_app`, `domain`, `other`. Empty for everything. |
| `status` | `any`, or `open` for currently live listings — **approximate**, see below. |
| `saleMethod` | `any`, `auction`, or `classified` (fixed price). |
| `minPrice` / `maxPrice` | Bounds on the listing price, in USD. |
| `maxItems` | Default 200; `0` for everything the query can reach. |
| `pageSize` | 100 max and the sensible default — Flippa limits by *request*, so fewer, larger pages is strictly better. |
| `minRequestInterval` | Leave unset; the actor picks a light default (0.5s with a proxy, 1.5s without). |
| `proxyConfiguration` | Residential, on by default. See above. |

***

### Known limits

- **10,000 is the highest total Flippa will report.** The listings beyond it
  exist but the count does not distinguish them.
- **Seller-reported financials** unless the verification flags say otherwise.
- Only the fields Flippa exposes on its listings API — no traffic analytics,
  and no seller contact details.
- **`status=open` is approximate.** Flippa's status filter lags the live
  listing state: measured twice over the same 290-result set, ~5 rows came
  back `completed`, clustered on later pages. Nothing is dropped or rewritten
  — every row carries its own authoritative `status`, and the summary reports
  `statusFilterIsApproximate` and `statusesSeen`. Filter on the row if you
  need exactness.
- A passed **leaf type** (e.g. `ecommerce_store`) is refused with an
  explanation; pass the category (`website`) instead.
- **bizbuysell.com and bizquest.com are deliberately not covered.** Both
  disallow `CCBot`, which this portfolio treats as part of the disqualifying
  AI-bot set.

# Actor input Schema

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

Flippa's own six top-level categories. These are CATEGORIES, not leaf types: 'website' covers e-commerce stores, content sites, SaaS, marketplaces and services, so rows come back with a more specific type than you asked for. Leave empty for everything.

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

Restrict to currently open listings, or take everything. NOTE: Flippa's status filter is approximate — it lags the live listing state, so a few rows can come back 'completed'. Every row carries its own authoritative `status`; filter on that if you need exactness.

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

Auctions or fixed-price classifieds.

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

Lower bound on the listing price.

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

Upper bound on the listing price.

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

Stop after this many listings. Set 0 for everything the query can reach — note Flippa clamps its own reported total at 10,000 for broad queries, so narrow by type or price to see the real count.

## `pageSize` (type: `integer`):

100 is the maximum and the sensible default: Flippa rate-limits by REQUEST, so fewer, larger pages is strictly better.

## `minRequestInterval` (type: `integer`):

Seconds between request starts. Leave unset to let the actor choose a light default (0.5s with a proxy, 1.5s without). Flippa's /search page is only mildly rate-limited, so this rarely needs raising.

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

Apify proxy. Residential is the default and takes a fresh exit IP per request, which removes any rate limit on very large runs. The /search page is lightly limited, so runs work without a proxy too.

## Actor input object example

```json
{
  "propertyTypes": [
    "website"
  ],
  "status": "any",
  "saleMethod": "any",
  "maxItems": 200,
  "pageSize": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `items` (type: `string`):

One row per scraped record. See the dataset's default view for field definitions.

# 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 = {
    "propertyTypes": [
        "website"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapyx/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 = { "propertyTypes": ["website"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapyx/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 '{
  "propertyTypes": [
    "website"
  ]
}' |
apify call scrapyx/flippa-listings-scraper --silent --output-dataset

```

## MCP server setup

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