# Flippa Business Listings Scraper (`automation-lab/flippa-business-listings-scraper`) Actor

Export public Flippa online-business listings with prices, revenue, profit, traffic, category, sale status, verification signals, and source URLs.

- **URL**: https://apify.com/automation-lab/flippa-business-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.48 / 1,000 item extracteds

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 Business Listings Scraper

Export public Flippa online-business listings for acquisition sourcing, valuation research, and recurring market monitoring.

The Actor turns Flippa search results into typed dataset rows with asking price, monthly revenue and profit, traffic signals, asset type, category, sale status, multiples, verification flags, and the canonical listing URL.

It works with guided filters or existing `flippa.com/search` URLs. No Flippa login or private seller data is required.

### What can this Flippa scraper do?

- Search open or recently sold Flippa listings.
- Cover websites, SaaS, ecommerce stores, Amazon businesses, apps, domains, and other supported asset types.
- Filter by price and public monthly profit.
- Request verified-revenue or verified-traffic listings.
- Preserve filters from a supplied Flippa search URL.
- Follow result pages until `maxItems` is reached.
- Deduplicate listings by stable Flippa listing ID.
- Export structured JSON, CSV, Excel, XML, RSS, or Parquet through Apify datasets.
- Support scheduled runs for recurring acquisition pipelines.

The Actor reads the public server-rendered search state instead of using Flippa's authenticated API. This keeps the default workflow HTTP-only and lightweight.

### Who is it for?

#### Acquisition entrepreneurs

Build a shortlist of online businesses that match budget, profit, category, and verification requirements.

#### Search funds and brokers

Collect a repeatable feed of public digital-business opportunities and compare asking prices or valuation multiples.

#### Market analysts

Study category mix, revenue, profit, traffic, and pricing across current or recently sold listings.

#### Data and automation teams

Send stable listing IDs and source URLs to a spreadsheet, warehouse, CRM, webhook, or change-detection pipeline.

### What data does it extract?

| Field group | Example fields |
| --- | --- |
| Identity | `listingId`, `listingUrl`, `title`, `summary` |
| Classification | `propertyType`, `category`, `monetization` |
| Price | `price`, `displayPrice`, `originalPrice`, `priceDropped` |
| Financials | `monthlyRevenue`, `monthlyProfit`, `trailingTwelveMonthRevenue` |
| Traffic | `monthlyUniqueVisitors`, `annualOrganicTraffic`, `verifiedTraffic` |
| Sale state | `status`, `saleMethod`, `bidCount`, `openToOffers`, `underOffer` |
| Valuation | `profitMultiple`, `revenueMultiple` |
| Verification | `verifiedRevenue`, `verifiedTraffic`, `manuallyVetted` |
| Seller context | `sellerLocation`, `superSeller`, `brokerSeller` |
| Provenance | `sourceSearchUrl`, `scrapedAt` |

Values are returned only when Flippa displays them in the public search result. Confidential listings can therefore contain null financial or traffic fields.

### How to scrape Flippa listings

1. Open the Actor in Apify Console.
2. Keep the default business types or choose narrower asset types.
3. Select **Open** or **Recently sold**.
4. Add price, profit, or verification filters if needed.
5. Set the maximum number of listings.
6. Click **Start**.
7. Open the **Dataset** tab to preview or export the records.
8. Save the task and add a schedule for recurring monitoring.

A useful first run is:

```json
{
  "propertyTypes": ["website", "saas", "ecommerce_store"],
  "status": "open",
  "sortBy": "most_relevant",
  "maxItems": 20,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### Input parameters

| Input | Type | Default | Purpose |
| --- | --- | --- | --- |
| `startUrls` | array | empty | Public `flippa.com/search` URLs whose filters should be reused |
| `propertyTypes` | string array | website, SaaS, ecommerce | Asset types to request |
| `status` | string | `open` | `open` or recently sold (`won`) listings |
| `saleMethods` | string array | all | Auction and/or classified listings |
| `minPrice` | number | empty | Minimum displayed price in USD |
| `maxPrice` | number | empty | Maximum displayed price in USD |
| `minMonthlyProfit` | number | empty | Minimum public average monthly profit |
| `maxMonthlyProfit` | number | empty | Maximum public average monthly profit |
| `verifiedRevenueOnly` | boolean | false | Request listings marked with verified revenue |
| `verifiedTrafficOnly` | boolean | false | Request listings marked with verified traffic |
| `sortBy` | string | `most_relevant` | Relevance or newest-first ordering |
| `maxItems` | integer | 100 | Maximum unique records, from 1 to 10,000 |
| `proxyConfiguration` | object | disabled | Optional Apify Proxy settings |

When both `startUrls` and guided filters are supplied, the guided filters override matching URL parameters. This makes saved tasks predictable.

Only public Flippa search URLs are accepted. Individual listing, login, account, and private API URLs fail with a clear input error.

### Output example

A current public result is normalized like this:

```json
{
  "listingId": "12857417",
  "listingUrl": "https://flippa.com/12857417",
  "title": "Profitable B2B SaaS for fitness coaches",
  "propertyType": "SaaS",
  "category": "Health and Beauty",
  "monetization": "Services & Subscriptions",
  "price": 436829,
  "displayPrice": "USD $436,829",
  "monthlyRevenue": 16671,
  "monthlyProfit": 13202,
  "monthlyUniqueVisitors": 511,
  "verifiedRevenue": false,
  "verifiedTraffic": true,
  "profitMultiple": 2.8,
  "revenueMultiple": 2.2,
  "status": "open",
  "saleMethod": "classified",
  "sellerLocation": "France",
  "sourceSearchUrl": "https://flippa.com/search?filter%5Bproperty_type%5D=saas",
  "scrapedAt": "2026-08-31T20:25:03.094Z"
}
```

Titles and metrics change as sellers update listings. Treat the example as a shape demonstration, not a promise that this listing remains available.

### How much does it cost to extract Flippa business listings?

Pay-per-event pricing has two parts:

- **Start:** $0.005 once per run.
- **Item:** one event for each unique listing saved.

Current item tiers are:

| Plan | Price per listing |
| --- | ---: |
| Free | $0.00092 |
| Bronze | $0.00080 |
| Silver | $0.000624 |
| Gold | $0.00048 |
| Platinum | $0.00032 |
| Diamond | $0.000224 |

At the Bronze tier, 20 listings cost about **$0.021** including the start event. One hundred listings cost about **$0.085**. One thousand listings cost about **$0.805**.

Failed requests and duplicates are not charged as item events. Apify platform usage may be billed separately according to your plan and proxy settings.

### Build an acquisition sourcing workflow

A practical recurring workflow is:

1. Create one task for each target segment, such as SaaS or ecommerce.
2. Apply budget and monthly-profit thresholds.
3. Schedule each task daily or weekly.
4. Use `listingId` as the stable key in your destination.
5. Compare `price`, `status`, and financial fields with the prior run.
6. Notify an analyst when a new listing or price change appears.

The Actor emits snapshots. It does not maintain history or send alerts itself; use Apify schedules, webhooks, and your destination to implement those steps.

### Monitor recently sold business comps

Set `status` to `won` and `sortBy` to `most_recent` to collect public recently sold records.

```json
{
  "propertyTypes": ["website", "ecommerce_store"],
  "status": "won",
  "sortBy": "most_recent",
  "maxItems": 25
}
```

Sold listings can help build directional comparable sets. They are not formal valuations, and some public fields may be hidden or unavailable.

### Use a Flippa search URL

Copy a filtered URL from Flippa and provide it in `startUrls`:

```json
{
  "startUrls": [
    { "url": "https://flippa.com/search?filter%5Bproperty_type%5D=saas&filter%5Bstatus%5D=open" }
  ],
  "minMonthlyProfit": 500,
  "maxItems": 50
}
```

The Actor preserves supported query filters, applies explicit input filters, and advances the `page[number]` parameter.

### Export and integrations

Every run writes to the default Apify dataset. From the Dataset tab you can:

- download JSON, CSV, Excel, XML, RSS, or Parquet;
- call the dataset API from a data pipeline;
- connect Google Sheets through an Apify integration;
- trigger a webhook after a successful run;
- send rows to Make, Zapier, n8n, or a custom service;
- load snapshots into BigQuery, Snowflake, Postgres, or another warehouse.

Use `listingId` for upserts and `scrapedAt` for snapshot timing.

### Run through the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~flippa-business-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"propertyTypes":["saas"],"status":"open","maxItems":20}'
```

To wait for the run and retrieve output in one request, use the synchronous dataset-items endpoint supported by the Apify API.

### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/flippa-business-listings-scraper').call({
  propertyTypes: ['saas'],
  status: 'open',
  minMonthlyProfit: 500,
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/flippa-business-listings-scraper').call(run_input={
    'propertyTypes': ['website', 'ecommerce_store'],
    'status': 'won',
    'sortBy': 'most_recent',
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI agents

Add the Actor-scoped Apify MCP endpoint to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/flippa-business-listings-scraper"
```

For **Claude Desktop**, **Cursor**, or **VS Code**, add this MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/flippa-business-listings-scraper"
    }
  }
}
```

Example prompts:

- “Use the Flippa Business Listings Scraper to return 20 open SaaS listings with at least $500 monthly profit.”
- “Collect the newest 25 recently sold website and ecommerce listings, then summarize price and profit multiples.”
- “Export verified-traffic Flippa businesses below $100,000 and group them by category.”

### Reliability and retries

The Actor uses Flippa's public server-rendered search state.

- Direct HTTP is the default and avoids unnecessary proxy transfer.
- Transient rate limits, network failures, and server errors receive bounded retries.
- Optional proxy mode uses a fresh session identity on retry.
- Challenge pages, invalid state, and unsupported URLs fail loudly instead of returning misleading empty datasets.
- Pagination stops at source exhaustion or `maxItems`.
- Records are deduplicated across multiple search URLs.

If Flippa changes its public search state, a run can fail until the parser is updated.

### Is it legal to scrape Flippa business listings?

This Actor extracts public marketplace information visible without signing in.

- It does not bypass NDAs, subscriptions, accounts, or confidential-detail gates.
- Confidential listings may expose only the limited fields Flippa shows publicly.
- It does not provide seller emails, private documents, or due-diligence materials.
- Data can change between runs and should be verified on the canonical listing page.
- High-frequency collection may trigger source rate limits.
- Respect Flippa's terms, robots guidance, applicable laws, and personal-data obligations.

You are responsible for your collection frequency, storage, and downstream use.

### Troubleshooting

#### Why are some revenue or traffic fields null?

Flippa does not display every metric for every public result. Confidential listings and unverified seller submissions often omit fields. Null means unavailable in the public search result, not zero.

#### Why did my run return no records?

Review the combined asset, status, price, profit, and verification filters. Try the same URL in a browser and relax one threshold at a time.

#### Why did the Actor reject my URL?

Only `flippa.com/search` URLs are supported. Use the guided filters for broad discovery. Individual listing and account pages are intentionally rejected.

#### Should I enable a proxy?

Usually no. Direct mode is the supported default. Enable an Apify Proxy only when your environment requires it or direct requests receive a source challenge.

### FAQ

#### Does it require a Flippa account?

No. The Actor reads only public search-result data.

#### Can it scrape individual listing details?

No. It exports the public fields shown in Flippa search results and links to the canonical listing. It does not enter confidential or account-gated detail flows.

#### Can it monitor changes?

Yes, as part of an Apify workflow. Schedule recurring task runs and compare snapshots by `listingId`. The Actor itself does not retain history or send alerts.

#### Does `maxItems` apply to each URL?

No. It is the total unique-record limit across all supplied search URLs.

#### Are monetary fields always USD?

The normalized numeric price reflects the USD value displayed by the public Flippa search result. Keep `displayPrice` for the exact source-formatted label.

#### Is this an official Flippa product?

No. This is an independent Actor and is not affiliated with or endorsed by Flippa.

### Related automation-lab Actors

For wider acquisition sourcing, combine this Actor with other public business-marketplace datasets from the `automation-lab` portfolio in Apify Store. Keep each source in a separate task, then normalize stable IDs, prices, revenue, profit, and source URLs in your downstream pipeline.

### Support

If a run fails, include the run URL, sanitized input, and the failing search URL in an Apify issue. Do not include credentials, private seller documents, or personal information.

# Actor input Schema

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

Optional public flippa.com/search URLs. Their query filters are preserved, and filters below are applied when provided.

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

Flippa asset types to include. Defaults to websites, SaaS, and ecommerce when no start URL is supplied.

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

Extract open listings or recently sold listings.

## `saleMethods` (type: `array`):

Optionally include auctions, classified asking-price listings, or both.

## `minPrice` (type: `number`):

Minimum displayed listing price.

## `maxPrice` (type: `number`):

Maximum displayed listing price.

## `minMonthlyProfit` (type: `number`):

Minimum public average monthly profit.

## `maxMonthlyProfit` (type: `number`):

Maximum public average monthly profit.

## `verifiedRevenueOnly` (type: `boolean`):

Only request listings marked by Flippa as having verified revenue.

## `verifiedTrafficOnly` (type: `boolean`):

Only request listings marked by Flippa as having verified traffic.

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

Use Flippa's relevance ranking or newest-first ordering.

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

Maximum unique listing records saved across all searches.

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

Optional Apify Proxy configuration. Direct requests are used by default because Flippa's public search page currently works without a proxy.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://flippa.com/search?filter%5Bproperty_type%5D=saas&filter%5Bstatus%5D=open"
    }
  ],
  "propertyTypes": [
    "website",
    "saas",
    "ecommerce_store"
  ],
  "status": "open",
  "verifiedRevenueOnly": false,
  "verifiedTrafficOnly": false,
  "sortBy": "most_relevant",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Unique Flippa business listing rows with price, financial, traffic, classification, verification, sale-state, and source fields.

# 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 = {
    "startUrls": [
        {
            "url": "https://flippa.com/search?filter%5Bproperty_type%5D=saas&filter%5Bstatus%5D=open"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/flippa-business-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 = {
    "startUrls": [{ "url": "https://flippa.com/search?filter%5Bproperty_type%5D=saas&filter%5Bstatus%5D=open" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/flippa-business-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 '{
  "startUrls": [
    {
      "url": "https://flippa.com/search?filter%5Bproperty_type%5D=saas&filter%5Bstatus%5D=open"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/flippa-business-listings-scraper --silent --output-dataset

```

## MCP server setup

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