# Flippa Listings Scraper (`fetch_cat/flippa-listings-scraper`) Actor

Scrape public Flippa marketplace listings with prices, revenue, profit, verification flags, categories, seller badges, and deal URLs.

- **URL**: https://apify.com/fetch\_cat/flippa-listings-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.29 / 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/platform/actors/running/actors-in-store#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 Scraper

Extract public Flippa marketplace listings for acquisition research, deal monitoring, broker analysis, and online-business intelligence. The Actor saves structured listing records with prices, revenue/profit metrics, verification flags, categories, seller/listing badges, and direct deal URLs.

Use it when you need repeatable Flippa data collection with CSV, JSON, Excel, API, MCP, or webhook workflows.

### At a glance

- **Primary job**: Collect public Flippa listings for websites, ecommerce stores, SaaS assets, apps, domains, and content businesses.
- **Input**: Use Flippa search/category URLs, direct listing URLs, property filters, price/revenue ranges, or monitoring mode.
- **Output**: One dataset row per unique public listing, keyed by `listingId` and `url`.
- **Best for**: Acquisition sourcing, valuation research, daily listing syncs, market maps, and investor/broker dashboards.

### Who is it for?

This Actor is built for acquisition entrepreneurs, business brokers, investment analysts, marketplace-monitoring teams, and researchers who need repeatable public Flippa deal data.

### Common workflows

- **Acquisition sourcing**: Search websites, SaaS, or ecommerce listings under a budget and export revenue/profit metrics.
- **Deal monitoring**: Schedule small ID-sync runs and compare fresh listing IDs with previous datasets.
- **Broker research**: Build lists of public Flippa opportunities by category, status, verification, and asking price.
- **Data enrichment**: Feed Flippa listing URLs and hostnames into CRMs, spreadsheets, BI tools, or other Apify Actors.
- **Automation**: Trigger webhooks or API jobs when a matching deal appears.

### Input recipes

Use these recipes before public Store examples are created.

**Websites under $50k**

```json
{
  "propertyTypes": ["website"],
  "priceMax": 50000,
  "maxItems": 25,
  "includeDetails": true
}
```

**SaaS revenue listings**

```json
{
  "propertyTypes": ["saas"],
  "revenueMin": 1000,
  "maxItems": 25,
  "includeDetails": true
}
```

**Direct listing detail audit**

```json
{
  "startUrls": [{ "url": "https://flippa.com/13526433" }],
  "maxItems": 1,
  "includeDetails": true
}
```

**Daily ID sync for a saved category**

```json
{
  "propertyTypes": ["website"],
  "mode": "idSync",
  "includeDetails": false,
  "maxItems": 50
}
```

### What data can you extract?

| Field | Description |
| --- | --- |
| `listingId` | Stable Flippa listing ID. |
| `url` | Public Flippa listing URL. |
| `title`, `summary` | Public listing title and short description. |
| `propertyName`, `propertyType`, `industry`, `category` | Marketplace classification and asset type. |
| `saleMethod`, `status`, `bidCount`, `endsAt` | Auction/classified/status and timing fields when public. |
| `currentPrice`, `displayPrice`, `buyItNowPrice`, `currency` | Public pricing fields. |
| `monthlyRevenue`, `monthlyProfit`, `pageViewsPerMonth`, `annualOrganicTraffic` | Public business performance metrics when exposed. |
| `hasVerifiedRevenue`, `hasVerifiedTraffic` | Flippa verification flags. |
| `hostname`, `externalUrl`, `thumbnailUrl` | Public website/domain and listing image fields. |
| `monetization`, `integrations`, `authorityScore` | Public monetization, connected-platform, and authority signals when exposed. |
| `countryName`, `establishedAt` | Public seller location and business establishment date when exposed. |
| `badges`, `sellerBadges`, `confidential`, `earlyAccess` | Listing and seller flags visible in public data. |
| `sourceUrl`, `sourceQuery`, `scrapedAt` | Diagnostics for tracing where each row came from. |
| `missingFields`, `errors` | Row-level diagnostics for unavailable optional fields or detail failures. |

### Input configuration

| Setting | JSON key | Use it for | Example |
| --- | --- | --- | --- |
| Flippa start URLs | `startUrls` | Search/category URLs or direct listing URLs. | `https://flippa.com/search?filter%5Bproperty_type%5D=website` |
| Search terms | `queries` | Label keyword-driven runs and future-proof query workflows. | `["shopify"]` |
| Maximum listings | `maxItems` | Cap saved rows and control spend. | `25` |
| Include details | `includeDetails` | Fetch public detail JSON for each listing. | `true` |
| Run mode | `mode` | Use `full` for records or `idSync` for lightweight monitoring. | `"full"` |
| Property types | `propertyTypes` | Limit to Flippa property types. | `["website"]` |
| Sale methods | `saleMethods` | Limit by sale method when supported. | `["auction"]` |
| Listing status | `status` | Filter by Flippa status when supported. | `"open"` |
| Price range | `priceMin`, `priceMax` | Set acquisition budget bounds. | `50000` |
| Revenue range | `revenueMin`, `revenueMax` | Find listings above/below monthly revenue. | `1000` |
| Verified only | `verifiedOnly` | Keep only listings with verified revenue or traffic. | `false` |
| Sort order | `sort` | Pass a Flippa sort value. | `"most_relevant"` |
| Proxy configuration | `proxyConfiguration` | Optional Apify Proxy settings for throttled runs. | `{ "useApifyProxy": false }` |

### Example input

```json
{
  "propertyTypes": ["website"],
  "maxItems": 10,
  "includeDetails": true,
  "verifiedOnly": false,
  "sort": "most_relevant"
}
```

### Example output

```json
{
  "listingId": "13526433",
  "url": "https://flippa.com/13526433-recipe-blog-on-wordpress-w-hbagency-and-adsense-income-ai-content-system-and-free-pinterest-traffic-260-mo-revenue-only-10-mo-35-yr-costs",
  "title": "Recipe blog on WordPress w/ HBAgency and AdSense income",
  "propertyName": "Kitch Recipes",
  "propertyType": "content_site",
  "industry": "food-and-drink",
  "saleMethod": "auction",
  "status": "open",
  "currentPrice": 2200,
  "displayPrice": 2800,
  "buyItNowPrice": 3000,
  "monthlyRevenue": 159,
  "monthlyProfit": 147,
  "hasVerifiedRevenue": true,
  "hasVerifiedTraffic": true,
  "hostname": "kitchrecipes.com",
  "confidential": false,
  "sourceUrl": "https://flippa.com/13526433",
  "scrapedAt": "2026-07-26T08:33:11.135Z",
  "missingFields": [],
  "errors": []
}
```

### Pricing

The Actor uses pay-per-event pricing. A **Run start** event is charged once when processing begins, and an **Item extracted** event is charged only after a listing row is successfully saved. Volume discounts depend on your Apify plan. See the [live Pricing tab](https://apify.com/fetch_cat/flippa-listings-scraper/pricing) for current rates.

### Tips for best results

- **Start small**: Use `maxItems: 10-25` until your filters return the right type of deal.
- **Use Flippa URLs**: Direct listing URLs are best for detail audits; search/category URLs are best for sourcing.
- **Keep monitoring runs focused**: Use `idSync` with `includeDetails: false` for cheap daily change detection.
- **Review empty runs**: A true zero-result run is valid only when Flippa reports no matching listings.
- **Do not add credentials**: This Actor is designed for public marketplace data only.

### API usage

Node.js:

```js
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/flippa-listings-scraper").call({
  propertyTypes: ["website"],
  maxItems: 10,
  includeDetails: true
});
console.log(run.defaultDatasetId);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetch_cat/flippa-listings-scraper").call(run_input={
    "propertyTypes": ["website"],
    "maxItems": 10,
    "includeDetails": True,
})
print(run["defaultDatasetId"])
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~flippa-listings-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"propertyTypes":["website"],"maxItems":10,"includeDetails":true}'
```

### MCP and AI agents

Use this Actor from MCP-compatible tools through the official Apify MCP Server.

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

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

Example prompt: "Run Flippa Listings Scraper for website listings under $50k and summarize verified revenue opportunities."

### Limits and caveats

- **Public data only**: The Actor does not use Flippa credentials, private deal rooms, messages, watchlists, or account-only documents.
- **Marketplace variability**: Some listings hide metrics, mark fields confidential, or omit optional values.
- **Source changes**: Flippa can change filters, field names, or availability; row diagnostics help identify missing optional fields.
- **Not valuation advice**: Use output as research data, not as financial, legal, tax, or investment advice.

### Legality and responsible use

Process only public data you are allowed to access. Follow Flippa's terms, Apify's terms, and applicable laws. Respect confidentiality flags and do not attempt to bypass access controls.

### Related actors

- [Website Contact Finder](https://apify.com/fetch_cat/website-contact-finder)
- [Shopify Products Scraper](https://apify.com/fetch_cat/shopify-products-scraper)
- [Google Shopping Results Scraper](https://apify.com/fetch_cat/google-shopping-results-scraper)
- [eBay Marketplace Scraper](https://apify.com/fetch_cat/ebay-marketplace-scraper)
- [Gumroad Products & Reviews Scraper](https://apify.com/fetch_cat/gumroad-products-reviews-scraper)

### FAQ

#### Can I export results?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and API access.

#### Why are some fields empty?

Flippa listings vary by asset type and confidentiality. The Actor leaves unavailable public fields empty instead of guessing.

#### Can this scrape seller contact details?

No. V1 focuses on public Flippa listing data and does not enrich external websites or collect private contact data.

#### Can I schedule monitoring?

Yes. Create a scheduled Apify task with `mode: "idSync"`, a low `maxItems`, and your preferred Flippa category/search filters.

### Support

Open an issue from the Actor page if a run fails or output looks wrong. Include the run ID or run URL, input JSON, expected output, actual output, and a reproducible public URL from Flippa.

# Actor input Schema

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

Flippa search/category URLs or direct listing URLs. Leave empty to use filters only.

## `queries` (type: `array`):

Optional Flippa marketplace keywords to search. The actor also records the query with each matching item.

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

Maximum unique listing records to save.

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

Fetch public listing detail JSON for each result when available.

## `mode` (type: `string`):

Use full for listing records or idSync for lightweight monitoring records using the same output schema.

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

Flippa property type filters, for example website, ecommerce, saas, app, domain, content.

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

Optional Flippa sale method filters such as auction or classified when supported by Flippa.

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

Optional listing status filter, for example open.

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

Minimum listing price in USD where supported by Flippa.

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

Maximum listing price in USD where supported by Flippa.

## `revenueMin` (type: `integer`):

Minimum monthly revenue in USD where supported by Flippa.

## `revenueMax` (type: `integer`):

Maximum monthly revenue in USD where supported by Flippa.

## `verifiedOnly` (type: `boolean`):

Keep only listings with verified revenue or verified traffic flags.

## `sort` (type: `string`):

Optional Flippa sort value, for example newest, most\_relevant, price\_asc, or price\_desc.

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

Optional Apify Proxy configuration. Default direct HTTP is used unless enabled.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://flippa.com/search?filter%5Bproperty_type%5D=website"
    }
  ],
  "queries": [
    "shopify"
  ],
  "maxItems": 10,
  "includeDetails": true,
  "mode": "full",
  "propertyTypes": [
    "website"
  ],
  "verifiedOnly": false,
  "sort": "most_relevant",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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 = {
    "startUrls": [{ "url": "https://flippa.com/search?filter%5Bproperty_type%5D=website" }],
    "queries": ["shopify"],
    "propertyTypes": ["website"],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/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 '{
  "startUrls": [
    {
      "url": "https://flippa.com/search?filter%5Bproperty_type%5D=website"
    }
  ],
  "queries": [
    "shopify"
  ],
  "propertyTypes": [
    "website"
  ]
}' |
apify call fetch_cat/flippa-listings-scraper --silent --output-dataset

```

## MCP server setup

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