# Flippa Listings Extractor (`kawsar/flippa-listings-extractor`) Actor

Flippa Listings Extractor collects live Flippa marketplace listings so you can find websites, apps, and online businesses for sale, then export price, revenue, and traffic data to JSON, CSV, or Excel.

- **URL**: https://apify.com/kawsar/flippa-listings-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** Developer tools, Automation, E-commerce
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 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 Listings Extractor

Flippa Listings Extractor collects live listings from the Flippa marketplace and returns them as clean, structured data. Search for websites, YouTube channels, apps, SaaS products, domains, and social media accounts that are for sale, then export everything to JSON, CSV, or Excel.

Filter by asset type, price range, sale method, keyword, or verified revenue and traffic, or just paste a Flippa search URL and let the actor read the filters for you. Every record carries the asking price, monthly revenue and profit, traffic, seller location, a listing image, sale status, and a direct link to the listing.

### Why use this actor

Flippa is one of the largest marketplaces for buying and selling online businesses, but its listings live behind a search interface that is slow to review at scale and impossible to sort in a spreadsheet. This actor turns any Flippa search into a dataset you can filter, sort, and analyze on your own terms.

- **Find deals faster.** Pull every listing that matches your budget and niche in one run instead of clicking through pages.
- **Track the market.** Run it on a schedule to catch new listings and price drops the day they happen.
- **Compare valuations.** Line up asking price against monthly revenue and profit to spot over- and under-priced assets.
- **Build a pipeline.** Keep a living dataset of acquisition targets that refreshes automatically.
- **Power your own tools.** Feed live marketplace data into dashboards, valuation models, alerts, or research notebooks.

### How it works

You can drive the actor two ways, and you can combine them:

1. **Paste Flippa search URLs.** Drop one or more search URLs from `https://flippa.com/search` into `searchUrls`. Any filters already in the URL (`filter[...]`, `q`, `sort_alias`) are read automatically. The easiest way to get one is to set up your filters on the Flippa search page and copy the address bar.
2. **Describe the search.** Skip the URL and set the filter fields directly (`propertyType`, `priceMin`, `keyword`, and so on).

The actor pages through the entire result set (25 listings per page), removes duplicate listings, and stops once it reaches your `maxItems` limit. Each listing becomes one row in the dataset.

### Input parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchUrls` | array of strings | – | Flippa search URLs. Filters in the URL are read automatically. Leave empty to build the search from the fields below. |
| `propertyType` | string | – | Asset type. One of `website`, `fba`, `saas`, `ecommerce_store`, `plugin_and_extension`, `ai_apps_and_tools`, `youtube`, `ios_app`, `android_app`, `game`, `crypto_app`, `social_media`, `newsletter`, `service_and_agency`, `service`, `projects_and_concepts`, `domain`, `other`. |
| `saleMethod` | string | `any` | Restrict to `auction` or `classified` listings. |
| `keyword` | string | – | Match against listing titles and descriptions. |
| `priceMin` | integer | – | Only listings priced at or above this amount (USD). |
| `priceMax` | integer | – | Only listings priced at or below this amount (USD). |
| `verifiedRevenueOnly` | boolean | `false` | Only listings with revenue verified by the marketplace. |
| `verifiedTrafficOnly` | boolean | `false` | Only listings with traffic verified by the marketplace. |
| `sortBy` | string | `default` | Sort order: `most_relevant`, `most_recent`, `most_active`, `lowest_price`, `highest_price`, `ending_soonest`, or `most_profitable`. |
| `maxItems` | integer | `50` | Maximum number of listings to collect per run (max 5000). |
| `requestTimeoutSecs` | integer | `45` | Per-request timeout in seconds. |

#### Example: scrape a category with a price band

```json
{
    "searchUrls": ["https://flippa.com/search?filter[property_type][]=youtube"],
    "priceMin": 1000,
    "priceMax": 50000,
    "verifiedRevenueOnly": true,
    "maxItems": 200
}
```

#### Example: build the search from filters

```json
{
    "propertyType": "website",
    "saleMethod": "classified",
    "keyword": "fitness",
    "sortBy": "highest_price",
    "maxItems": 100
}
```

### Output

Each listing is saved as one record. Example:

```json
{
    "listingId": "12021962",
    "url": "https://flippa.com/12021962",
    "title": "E-commerce SaaS that finds winning products. 3k MRR, highly profitable.",
    "summary": "E-commerce SaaS that finds winning products. 3k MRR, low churn.",
    "propertyType": "SaaS",
    "category": "Business",
    "monetization": "Services & Subscriptions",
    "status": "open",
    "saleMethod": "classified",
    "priceLabel": "Asking Price",
    "price": 14881,
    "priceText": "USD $14,881",
    "originalPrice": null,
    "priceDropped": false,
    "priceDropPercent": null,
    "bidCount": 0,
    "profitPerMonth": 1354,
    "revenuePerMonth": 1447,
    "profitMultiple": 0.9,
    "revenueMultiple": 0.9,
    "ttmRevenue": null,
    "targetRaiseAmount": null,
    "confidential": false,
    "hasVerifiedRevenue": false,
    "hasVerifiedTraffic": false,
    "countryName": "United Arab Emirates",
    "ageYears": 2,
    "ageLabel": "Site Age",
    "uniquesPerMonth": 1000,
    "annualOrganicTraffic": null,
    "authorityScore": null,
    "appRating": null,
    "propertyName": "spyderads.app",
    "primaryPlatform": null,
    "superSeller": false,
    "brokerSeller": false,
    "brokerName": null,
    "sponsored": false,
    "editorsChoice": false,
    "managedByFlippa": false,
    "readyMade": false,
    "underOffer": false,
    "openToOffer": false,
    "watched": false,
    "currencyLabel": "USD $",
    "endsAt": "2026-12-18T09:11:19+11:00",
    "thumbnailUrl": "https://static2.flippa.com/webp_example.webp",
    "scrapedAt": "2026-09-05T09:26:55+00:00"
}
```

#### Field reference

| Field | Meaning |
|-------|---------|
| `listingId` | Flippa listing ID. |
| `url` | Direct link to the listing page. |
| `title` | Full listing title. |
| `summary` | Short seller-written summary. |
| `propertyType` | Asset type label, for example `SaaS`, `Website`, `YouTube`. |
| `category` | Industry or niche category. |
| `monetization` | How the asset makes money. |
| `status` | Listing status, for example `open`. |
| `saleMethod` | `auction` or `classified`. |
| `priceLabel` | Label Flippa shows for the price, e.g. `Asking Price` or `Current Bid`. |
| `price` | Asking price or current bid (USD). |
| `priceText` | Price as displayed, including currency, e.g. `USD $14,881`. |
| `originalPrice` | Price before a drop, when the listing was reduced (USD). |
| `priceDropped` | Whether the price has been reduced. |
| `priceDropPercent` | Percentage the price dropped, when applicable. |
| `bidCount` | Number of bids on an auction. |
| `profitPerMonth` | Reported average monthly profit (USD). |
| `revenuePerMonth` | Reported average monthly revenue (USD). |
| `profitMultiple` | Asking price as a multiple of annual profit. |
| `revenueMultiple` | Asking price as a multiple of annual revenue. |
| `ttmRevenue` | Trailing-twelve-month revenue, when published (USD). |
| `targetRaiseAmount` | Capital-raise target for invest listings (USD). |
| `confidential` | Whether details are hidden until an NDA is signed. |
| `hasVerifiedRevenue` | Revenue verified by the marketplace. |
| `hasVerifiedTraffic` | Traffic verified by the marketplace. |
| `countryName` | Seller country. |
| `ageYears` | Age of the asset in years. |
| `ageLabel` | Label Flippa uses for the age metric, e.g. `Site Age`. |
| `uniquesPerMonth` | Monthly unique visitors. |
| `annualOrganicTraffic` | Estimated annual organic traffic. |
| `authorityScore` | Domain/authority score when available. |
| `appRating` | App store rating for mobile app listings. |
| `propertyName` | Display name of the asset (hostname, channel name, or NDA prompt). |
| `primaryPlatform` | Primary platform the asset runs on, when set. |
| `superSeller` | Whether the seller holds Super Seller status. |
| `brokerSeller` | Whether the listing is sold through a broker. |
| `brokerName` | Broker name, when a broker handles the sale. |
| `sponsored` | Whether the listing is sponsored. |
| `editorsChoice` | Whether Flippa flags it as an editor's choice. |
| `managedByFlippa` | Whether Flippa manages the sale. |
| `readyMade` | Whether the asset is a ready-made / starter site. |
| `underOffer` | Whether the listing is currently under offer. |
| `openToOffer` | Whether the seller is open to offers. |
| `watched` | Whether the current viewer watches it (always `false` for anonymous runs). |
| `currencyLabel` | Currency prefix shown for prices, e.g. `USD $`. |
| `endsAt` | When the listing or auction ends. |
| `thumbnailUrl` | Listing image URL. |
| `scrapedAt` | UTC timestamp of when the record was collected. |

### Why some fields are null

The actor returns exactly what Flippa publishes for each listing. A field is `null` when the marketplace does not provide a value for it, which is normal and expected in these cases:

- **`appRating`** is filled only for mobile app listings (`ios_app`, `android_app`). Other asset types have no app rating, so this field is `null` for them.
- **`profitPerMonth`, `revenuePerMonth`, `uniquesPerMonth`, `propertyName`** are often hidden on confidential listings until a buyer signs an NDA, so they can be `null` or replaced with an NDA prompt.
- **`originalPrice` and `priceDropPercent`** are set only on listings whose price has been reduced.
- **`brokerName`** is `null` unless a broker handles the sale.

If you only want listings that report a specific metric, filter the dataset after the run, or use `verifiedRevenueOnly` and `verifiedTrafficOnly` to narrow the search up front.

### Export and integrate

Results are stored in an Apify dataset. You can:

- Download as JSON, CSV, Excel, or HTML from the run's Storage tab.
- Pull records through the Apify API or client libraries.
- Trigger the actor on a schedule and connect it to webhooks, Google Sheets, or your own pipeline.

### Tips

- Start with a small `maxItems` while you dial in filters, then raise it once the results look right.
- To monitor a niche over time, save an input with your filters and run it on a daily or weekly schedule.
- Combine a search URL in `searchUrls` with `priceMin` and `priceMax` to focus on a specific budget within that category.

### Frequently asked questions

**Can I scrape more than one category at once?**
Yes. Add several URLs to `searchUrls`, or run separate searches. Duplicate listings across searches are removed automatically.

**How current is the data?**
Every run pulls live listings at that moment, so schedule it as often as you need fresh results.

**Does it return sold or closed listings?**
It returns whatever matches your search on Flippa, which is primarily active listings. Use `status` in the output to filter further.

**Why do I get fewer results than the category shows?**
Collection stops at your `maxItems` limit. Increase it to pull the full set.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste one or more Flippa search URLs (from https://flippa.com/search). The actor reads any filters in the URL and returns every matching listing. Leave empty to build a search from the filter fields below.

## `propertyType` (type: `string`):

Filter listings by asset type. Ignored when a search URL already specifies one.

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

Limit results to auction or classified listings.

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

Optional keyword to match against listing titles and descriptions.

## `priceMin` (type: `integer`):

Only return listings priced at or above this amount.

## `priceMax` (type: `integer`):

Only return listings priced at or below this amount.

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

Return only listings with revenue verified by the marketplace.

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

Return only listings with traffic verified by the marketplace.

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

Order in which listings are collected.

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

Maximum number of listings to collect per run.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "searchUrls": [
    "https://flippa.com/search?filter[property_type][]=saas&filter[has_verified_revenue]=true"
  ],
  "saleMethod": "any",
  "keyword": "fitness",
  "priceMin": 1000,
  "priceMax": 50000,
  "verifiedRevenueOnly": false,
  "verifiedTrafficOnly": false,
  "sortBy": "default",
  "maxItems": 50,
  "requestTimeoutSecs": 45
}
```

# Actor output Schema

## `properties` (type: `string`):

Extract live Flippa marketplace listings with price, revenue, traffic, and seller data, then export to JSON, CSV, or Excel.

# 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 = {
    "searchUrls": [
        "https://flippa.com/search?filter[property_type][]=website"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/flippa-listings-extractor").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 = { "searchUrls": ["https://flippa.com/search?filter[property_type][]=website"] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/flippa-listings-extractor").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 '{
  "searchUrls": [
    "https://flippa.com/search?filter[property_type][]=website"
  ]
}' |
apify call kawsar/flippa-listings-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kawsar/flippa-listings-extractor"
        }
    }
}

```

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/GIoFqTo9edza8UWw4/builds/e2deHcgJ07JM7hszP/openapi.json