# Flippa Listings Scraper (`axiomworks/flippa-empire-flippers-listings-scraper`) Actor

Collect public business listings from Flippa and Empire Flippers and return comparable records with asking price, monthly revenue and profit, profit multiple, age, business type, niche, location and status. Search by keyword and filters, or provide listing URLs.

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

## Pricing

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

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

**Returns:** one row per business listing with `title`, `askingPrice`, `monthlyRevenue`, `monthlyProfit`, `profitMultiple`, `ageYears`, `businessType`, `location`.
**Input:** `{"keyword": "newsletter", "sources": ["flippa", "empireflippers"], "maxItems": 50}`
**Best for:** acquisition deal sourcing, business valuation benchmarks, tracking asking prices and sold deals over time.

```json
{
    "id": "flippa-14543520",
    "source": "flippa",
    "title": "Apron Belly",
    "askingPrice": 999,
    "currency": "USD",
    "businessType": "Content",
    "niche": "Health and Beauty",
    "location": "Pakistan",
    "status": "for_sale"
}
```

### What does Flippa Empire Flippers Scraper do?

Flippa Empire Flippers Scraper is a Flippa scraper and Empire Flippers API client in one Actor. It collects online business listings (ecommerce stores, Amazon FBA brands, SaaS products, content sites, newsletters, apps, agencies and more) from the public Flippa marketplace and from the open Empire Flippers listing API, and returns them in a single record shape. You search once and get comparable rows: asking price, monthly revenue, monthly profit, profit multiple, business age, business type, niche, location, status and the seller's summary.

You can search by keyword, business type, price, profit, revenue, age and profit multiple, choose open listings or sold deals, and sort by newest, price or profit. You can also paste exact Flippa or Empire Flippers addresses (a filtered Flippa search, a single listing, an Empire Flippers category page) and get the listings behind them. No login is needed; the Actor reads only public pages and the public API.

Typical jobs: building a deal-flow list for an acquisition fund, comparing multiples across business types before you buy or sell, watching how asking prices move, and collecting sold deals as valuation evidence.

### What data can you get from Flippa and Empire Flippers?

Every record has the same fields whichever marketplace it came from. Fields a marketplace does not publish are returned as `null`.

| Field | Description | Example |
|---|---|---|
| `id` | Stable record id, the marketplace name plus the listing number | flippa-14543520 |
| `source` | Marketplace the listing came from: flippa or empireflippers | flippa |
| `listingId` | The marketplace's own listing number | 14543520 |
| `title` | Listing headline | Apron Belly |
| `url` | Public page of the listing | https://flippa.com/14543520-... |
| `askingPrice` | Asking price as a number; null when the seller has not set one | 999 |
| `currency` | Currency code of the money fields | USD |
| `monthlyRevenue` | Average monthly revenue; rounded to three significant digits on Flippa search results | null |
| `monthlyProfit` | Average monthly net profit; rounded to three significant digits on Flippa search results | null |
| `profitMultiple` | Annual profit multiple published by the marketplace; null when not published | null |
| `ageYears` | Age of the business in years | 0 |
| `businessType` | Business model label used by the marketplace | Content |
| `niche` | Industry or niche label used by the marketplace | Health and Beauty |
| `monetizations` | All revenue models of the business (one on Flippa, several on Empire Flippers) | \["Content"] |
| `location` | Business location: place name on Flippa, ISO country code on Empire Flippers | Pakistan |
| `status` | for_sale, sold or other | for_sale |
| `listedBy` | Who handles the sale | Marketplace · Listed by Owner |
| `verified` | True when the marketplace marks the listing verified or vetted | false |
| `description` | Seller summary of the business; null when the page does not show one | 91-article UK women's health site... |
| `listedAt` | ISO 8601 date the listing went live; Empire Flippers only | null |
| `scrapedAt` | ISO 8601 time of the run | 2026-10-19T00:25:56.216Z |
| `sourceUrl` | Page or API request the record was read from | https://flippa.com/search?... |

Some differences between the two marketplaces are worth knowing. Empire Flippers publishes monthly figures, an annual profit multiple, a listing date and a written summary when available. Unpriced listings can have a null profit multiple. Flippa search pages show rounded figures (three significant digits), and some Flippa listings leave revenue, profit or the multiple empty. Flippa search results carry no listing date, so `listedAt` is `null` for them. When you paste a single Flippa listing URL, the Actor reads the public summary of that page: the exact monthly profit, the location, the description, and a monthly revenue estimated as monthly profit divided by the stated profit margin.

### How to use Flippa Empire Flippers Scraper

1. Open the Actor in Apify Console and go to the Input tab.
2. Leave the marketplaces on both, or pick one. Add a keyword, business types and any price, profit or age limits you care about. Or paste start URLs instead.
3. Set `maxItems` to the number of listings you want. The limit counts across both marketplaces and all start URLs together.
4. Click Start. Results appear in the Output tab as they are found.
5. Export the dataset as JSON, CSV, Excel, XML or HTML, or read it through the API.

When both marketplaces are searched, results alternate one by one (one from Flippa, one from Empire Flippers), so a small `maxItems` still gives you a mix. Flippa lists thousands of open listings and Empire Flippers a few hundred, so a large `maxItems` is filled mostly from Flippa once Empire Flippers runs out. Range filters are sent to the marketplaces and checked again on the results. A listing whose value for a filtered field is unknown (for example a Flippa listing without revenue) is kept, not dropped.

If a keyword, address or filter combination matches nothing, the run still finishes successfully with zero results and a message in the status line telling you what to change. A start URL that cannot be read (a listing that was removed, for example) is reported in the log and the other start URLs continue.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `startUrls` | array of URLs | No | Flippa search or listing URLs and Empire Flippers marketplace, category or listing URLs. When set, only these are crawled. |
| `sources` | array | No | `flippa`, `empireflippers` or both (default both). Used when no start URLs are given. |
| `keyword` | string | No | Search words passed to each marketplace's own search. |
| `businessTypes` | array | No | ecommerce, amazon_fba, amazon_kdp, saas, content, newsletter, agency_service, mobile_app, youtube_social, marketplace, domain, other. |
| `status` | string | No | for_sale (default), sold or all. |
| `sortBy` | string | No | newest (default), price_asc, price_desc or profit_desc. |
| `maxItems` | integer | No | Total results across everything, default 50, 0 for no limit, at most 10000. |
| `minPrice / maxPrice` | integer | No | Asking price range in US dollars. |
| `minMonthlyProfit / maxMonthlyProfit` | integer | No | Monthly net profit range in US dollars. |
| `minMonthlyRevenue / maxMonthlyRevenue` | integer | No | Monthly revenue range in US dollars. |
| `minAgeYears / maxAgeYears` | number | No | Business age range in years. |
| `minProfitMultiple / maxProfitMultiple` | number | No | Range of the annual profit multiple. |
| `flippaCategories, flippaIndustries` | array | No | Raw Flippa category and industry slugs for power users. |
| `efMonetizations, efNiches` | array | No | Raw Empire Flippers monetization and niche names for power users. |
| `proxyConfiguration` | object | No | Apify Proxy settings, default datacenter. |

Business types map to each marketplace's own categories. For example `saas` searches the SaaS, AI apps and plugin categories on Flippa and the SaaS, Subscription and Application monetizations on Empire Flippers. A business type that one marketplace does not have (such as `domain` on Empire Flippers) skips that marketplace.

```json
{
    "keyword": "newsletter",
    "sources": ["flippa", "empireflippers"],
    "businessTypes": ["newsletter", "content"],
    "status": "for_sale",
    "sortBy": "price_desc",
    "minPrice": 1000,
    "maxPrice": 250000,
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

Supported start URLs include Flippa search addresses with any filter or sort, Flippa listing addresses, Empire Flippers marketplace addresses with keyword and price filters, Empire Flippers category pages, the Empire Flippers app marketplace addresses and Empire Flippers listing addresses.

```json
{
    "startUrls": [
        { "url": "https://flippa.com/search?filter%5Bstatus%5D=open&filter%5Blisting_category%5D%5B%5D=amazon-fba" },
        { "url": "https://empireflippers.com/marketplace/saas-businesses-for-sale/" },
        { "url": "https://empireflippers.com/listing/97464/" }
    ],
    "maxItems": 30
}
```

### Output

Each run writes one dataset item per listing. A real item from a run with the keyword "amazon" on Flippa:

```json
{
    "id": "flippa-14543520",
    "source": "flippa",
    "listingId": "14543520",
    "title": "Apron Belly",
    "url": "https://flippa.com/14543520-91-article-uk-women-s-health-site-on-apron-belly-and-fupa-2-3k-users-in-90-days-mostly-google-organic-pre-revenue-and-affiliate-ready",
    "askingPrice": 999,
    "currency": "USD",
    "monthlyRevenue": null,
    "monthlyProfit": null,
    "profitMultiple": null,
    "ageYears": 0,
    "businessType": "Content",
    "niche": "Health and Beauty",
    "monetizations": ["Content"],
    "location": "Pakistan",
    "status": "for_sale",
    "listedBy": "Marketplace · Listed by Owner",
    "verified": false,
    "description": "91-article UK women's health site on apron belly and FUPA. 2.3k users in 90 days, mostly Google organic. Pre-revenue and affiliate-ready.",
    "listedAt": null,
    "scrapedAt": "2026-10-19T00:25:56.216Z",
    "sourceUrl": "https://flippa.com/search?query%5Bkeyword%5D=amazon&filter%5Bstatus%5D=open&sort_alias=most_recent&page=1&pagination=true"
}
```

The dataset has an Overview table view with the most useful columns. Export formats: JSON, CSV, Excel, XML and HTML. Empire Flippers items look the same, with exact figures, a country code in `location`, a list of monetizations and a `listedAt` date.

### How much does it cost to scrape Flippa and Empire Flippers?

Flippa Empire Flippers Scraper is charged per result returned. You pay only for the listings saved to the dataset, and `maxItems` caps how many that can be. If you set a maximum cost per run in the run options, the Actor stops as soon as that budget is used and says so in the status line. See the Pricing tab for the current price.

### Use with AI agents (MCP)

Connect Flippa Empire Flippers Scraper to Claude, Cursor or any MCP client through the Apify MCP server:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?tools=axiomworks/flippa-empire-flippers-listings-scraper"
        }
    }
}
```

Example prompts:

1. "Find the 20 newest Amazon FBA businesses for sale on Flippa and Empire Flippers and list asking price, monthly profit and profit multiple."
2. "Which SaaS businesses for sale under a given asking price have the lowest profit multiple? Use the Flippa and Empire Flippers listings scraper."
3. "Get sold newsletter businesses from Flippa sorted by monthly profit so I can compare what they sold for."

### Integrations and API

Run Flippa Empire Flippers Scraper from your own code with the Apify API. Set `APIFY_TOKEN` to your Apify API token (send it in the `Authorization` header, never in the URL).

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("axiomworks/flippa-empire-flippers-listings-scraper").call(run_input={"keyword": "amazon", "maxItems": 50})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('axiomworks/flippa-empire-flippers-listings-scraper').call({ keyword: 'amazon', maxItems: 50 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~flippa-empire-flippers-listings-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword": "amazon", "maxItems": 50}'
```

On the Integrations tab you can connect the Actor to Make, Zapier, n8n, Google Sheets and webhooks, and schedule it to run daily or weekly to monitor new listings.

### FAQ

**How many listings can I get?**
Flippa has thousands of open listings and Empire Flippers a few hundred for sale, plus thousands of sold deals. `maxItems` goes up to 10000 per run.

**Why are some Flippa revenue or profit values empty?**
Flippa sellers do not always publish them: search cards can show `N/A` for monthly revenue or profit, and auction cards can omit Profit Multiple even when profit is available. The field is `null` in those cases. The Actor does not treat missing amounts as zero or calculate a replacement multiple from a starting bid. Empire Flippers also returns a null multiple for some unpriced listings. Fill rates therefore depend on the listings matching your input, rather than a guaranteed percentage.

**Why do Flippa figures look rounded?**
Flippa search cards abbreviate numbers, for example 25.6K, so the Actor keeps three significant digits. Empire Flippers returns exact values.

**Why did my run return zero results?**
The keyword or filters matched nothing, or the marketplace blocked the request after several retries. The status message says which. Loosen the filters, or switch the proxy to residential and run again.

**Can I get sold listings?**
Yes. Set `status` to `sold` (or `all`). Sold Flippa deals show the final asking price on the card.

**Does it need a login?**
No. The Actor reads public listing pages and the public Empire Flippers listing API. Private details such as the seller's financial reports, the seller's identity and the full financial tabs on Flippa are not included.

**Are duplicates removed?**
Yes. A listing appears once per run, even when several start URLs or pages contain it.

**How fresh is the data?**
It is read live from the marketplaces at run time, and `scrapedAt` records when.

### Is it legal to scrape Flippa and Empire Flippers?

The Actor collects only information that these marketplaces show publicly without an account. Listing data describes businesses, but it can include names or personal details in free text, so check the rules that apply to you (for example GDPR) before you store or share it, and respect each marketplace's terms. This is not legal advice.

Flippa Empire Flippers Scraper is an independent tool. It is not affiliated with, endorsed by or sponsored by Flippa or Empire Flippers.

### Feedback

Found a bug or need a field that isn't here? Open an issue on the Issues tab and we'll look at it.

# Actor input Schema

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

Optional. Flippa search or listing URLs (https://flippa.com/search?..., https://flippa.com/14144546) and Empire Flippers marketplace, category or listing URLs (https://empireflippers.com/listing/97464/). When set, only these are crawled and the filters below are applied to their records; leave empty to search by keyword and filters.

## `sources` (type: `array`):

Marketplaces to search when Start URLs is empty: 'flippa', 'empireflippers' or both (default both). With both, results alternate one by one so a small maxItems returns a mix.

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

Optional search words, e.g. 'amazon' or 'tienda'. Matched by each marketplace's own search. Leave empty to list everything that fits the other filters.

## `businessTypes` (type: `array`):

Optional business models, mapped to each marketplace's own categories. A marketplace with no matching category (e.g. domain on Empire Flippers) is skipped. Leave empty for all types.

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

'for_sale' (default) returns open listings, 'sold' returns completed sales, 'all' returns both. Ignored for Flippa start URLs, whose own filter decides.

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

Order of results within each marketplace: 'newest' (default), 'price_asc', 'price_desc' or 'profit_desc' (highest monthly profit first).

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

Maximum listings returned in total across both marketplaces and all start URLs, 1-10000, default 50; 0 means no limit. The run stops when this many are saved and you are charged only for results returned.

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

Proxy for all requests, default Apify Proxy (datacenter). Blocked requests are retried on a new IP automatically; switch to residential only if runs return nothing.

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

Only listings asking at least this many US dollars, e.g. 100000. Applied by the marketplaces and again on the results.

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

Only listings asking at most this many US dollars, e.g. 1000000.

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

Only listings with at least this monthly net profit in US dollars, e.g. 5000.

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

Only listings with at most this monthly net profit in US dollars.

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

Only listings with at least this monthly revenue in US dollars. Flippa figures are rounded to 3 digits on search pages.

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

Only listings with at most this monthly revenue in US dollars.

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

Only businesses at least this many years old, e.g. 2 or 0.5.

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

Only businesses at most this many years old.

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

Only listings priced at least this many times annual profit, e.g. 2.5 (annual multiple, like the 'x' shown by Flippa).

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

Only listings priced at most this many times annual profit, e.g. 4.

## `flippaCategories` (type: `array`):

Raw Flippa category slugs added to Business types, e.g. 'amazon-fba', 'saas', 'newsletters', 'youtube-channels'. Searches only Flippa unless Empire Flippers filters are also set.

## `flippaIndustries` (type: `array`):

Raw Flippa industry slugs, e.g. 'health-and-beauty', 'travel', 'food-and-drink', 'home-and-garden'.

## `efMonetizations` (type: `array`):

Raw Empire Flippers monetization names added to Business types, e.g. 'Amazon FBA', 'SaaS', 'Affiliate', 'Lead Gen'. Searches only Empire Flippers unless Flippa filters are also set.

## `efNiches` (type: `array`):

Raw Empire Flippers niche names, e.g. 'Pet Care', 'Health & Fitness', 'Automotive'.

## Actor input object example

```json
{
  "sources": [
    "flippa",
    "empireflippers"
  ],
  "status": "for_sale",
  "sortBy": "newest",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset with one item per result, in the order found.

# 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 = {
    "sources": [
        "flippa",
        "empireflippers"
    ],
    "status": "for_sale",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/flippa-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 = {
    "sources": [
        "flippa",
        "empireflippers",
    ],
    "status": "for_sale",
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/flippa-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 '{
  "sources": [
    "flippa",
    "empireflippers"
  ],
  "status": "for_sale",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call axiomworks/flippa-empire-flippers-listings-scraper --silent --output-dataset

```

## MCP server setup

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