# Flippa Scraper: Listings, Sold Comps & Deal Alerts (`dead00/flippa-scraper-listings-sold-comps-deal-alerts`) Actor

crape businesses for sale on Flippa, and see which ones are actually good deals. Every listing comes with valuation multiples and a value score based on what similar businesses really sold for on Flippa. Schedule it to get alerts for new listings, price drops and sales.

- **URL**: https://apify.com/dead00/flippa-scraper-listings-sold-comps-deal-alerts.md
- **Developed by:** [Dead](https://apify.com/dead00) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 listing scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Flippa Scraper: Listings, Sold Comps & Deal Alerts

Scrape businesses for sale on Flippa, and see which ones are actually good deals. Every listing comes with valuation multiples and a **value score** based on what similar businesses **really sold for** on Flippa. Schedule it to get alerts for new listings, price drops and sales.

Websites, SaaS, ecommerce stores, Amazon FBA, iOS and Android apps, AI tools, YouTube channels, newsletters, agencies and more. No login, no API key.

### What makes it different

| | Typical Flippa scrapers | This actor |
|---|---|---|
| Listings with price, revenue, profit, age, location | ✅ | ✅ |
| Revenue and profit multiples, payback months, margin, age | Some | ✅ |
| **Sold comps:** what businesses actually sold for | ❌ | ✅ |
| **Value score** vs real sale prices | ❌ | ✅ |
| **Alerts:** new listings, price drops, sold, ended | ❌ | ✅ |
| **Price drops** shown on Flippa (original price, % off) | Some | ✅ |
| Filters Flippa lacks: profit range, max multiple, keywords | ❌ | ✅ |

### How it works

1. **Sold comps.** For each business type, it reads recently sold Flippa listings and calculates the median sold price, price range, and the median revenue and profit multiples they sold at.
2. **Value score.** Each listing's profit multiple is compared with those comps. A SaaS asking 2x annual profit, where similar SaaS sold for 3x, shows `vsCompsPercent: -33` and a high `valueScore`.
3. **Monitoring.** It remembers what it saw. The next run flags new listings, price changes, and listings that sold (with the final price) or ended.

### How to use

- **What to get:** listings for sale scored against sold comps (recommended), listings only, or sold listings for valuation research.
- **Business types:** pick one or more; each gets its own comps.
- **Filters:** price range, minimum monthly profit or revenue, maximum profit multiple (e.g. `3` for 3x), and keywords (e.g. `AI`, `Shopify`, `newsletter`). A price range also applies to the sold comps, so listings are compared with similar-sized sales.

#### Daily deal alerts

1. Set your filters, e.g. SaaS under $100k, at most 3x profit.
2. Turn on **Only output changes**.
3. Schedule the actor daily and connect Apify's email or Slack integration.

Each run then returns only what's new: fresh listings, price changes, sales (with the sale price) and removed listings.

### Output

Every number comes **twice**: as a plain number for sorting, filtering and spreadsheets, and as readable text in Flippa's own style (`USD $4.37K`, `USD $2.52M`, `4.1x`). Use whichever you prefer.

A listing for sale:

```json
{
  "type": "listing",
  "id": "11816135",
  "url": "https://flippa.com/11816135-social-media-entertainment-business",
  "status": "open",
  "title": "Social media entertainment business founded in 2014, generating $2M in revenue with a 33% profit margin.",
  "propertyType": "SaaS",
  "industry": "Internet",
  "askingPrice": 2520000,
  "askingPriceText": "USD $2.52M",
  "originalPrice": 3500000,
  "originalPriceText": "USD $3.5M",
  "priceDropPercent": 28,
  "priceDropText": "28% off (was USD $3.5M)",
  "monthlyRevenue": 160000,
  "monthlyRevenueText": "USD $160K",
  "monthlyProfit": 51700,
  "monthlyProfitText": "USD $51.7K",
  "annualProfitText": "USD $620K",
  "profitMultiple": 4.1,
  "profitMultipleText": "4.1x",
  "paybackMonths": 48.7,
  "paybackText": "49 months (4.1 years)",
  "profitMargin": 32.3,
  "profitMarginText": "32%",
  "ageYears": 12,
  "ageText": "12 years",
  "sellerLocation": "Canada",
  "managedByFlippa": true,
  "vsCompsPercent": 36.7,
  "vsCompsText": "37% above typical sale multiple",
  "valueScore": 42,
  "valueRating": "Fair",
  "change": "price_drop",
  "changeText": "Price dropped 28% (USD $3.5M → USD $2.52M)",
  "missingFields": [],
  "dataNote": null
}
```

**Values the seller didn't publish** are never silent blanks. The text field says `"Not disclosed"`, `missingFields` lists them (e.g. `["price", "monthlyProfit"]`), and `dataNote` explains why, e.g. *"Price not shown publicly (seller asks buyers to make an offer or contact them)"*. Everything that can be calculated (annual figures, multiples, payback, margin) is calculated.

**Ratings and changes in plain words:** `valueRating` is "Great deal", "Good", "Fair" or "Expensive", and `changeText` reads like "New listing", "Price dropped 20% (USD $216K → USD $173K)", "Sold for USD $19.6K" or "Removed from Flippa".

A comps summary row per business type (free):

```json
{
  "type": "comps",
  "propertyType": "saas",
  "withPublicSoldPrice": 300,
  "medianSoldPrice": 75350,
  "medianSoldPriceText": "USD $75.4K",
  "soldPriceRangeText": "USD $34.5K to USD $164K",
  "medianProfitMultipleText": "3.0x",
  "medianRevenueMultipleText": "1.5x",
  "medianPaybackText": "36 months (3.0 years)",
  "summaryText": "300 recent SaaS sales: typically USD $75.4K, at 3.0x annual profit"
}
```

**Nothing skipped:** after each business type, the run compares what it read with the number of listings Flippa itself reports. The run's summary (the `OUTPUT` record) shows this per type (`flippaReportsForSale`, `listingsRead`, `readAllPages`) and warns if any pages came back short.

### Pricing

| Event | Price per 1,000 |
|---|---|
| Listing scraped | $3.00 |
| Actor start (per run) | $0.00005 |

Comps summary rows and the sold listings used as the comparison baseline are **free**. In "only changes" mode you pay only for the changes. Set a **Maximum cost per run** in Run options; when it's reached, the actor stops and keeps its results.

### Good to know

- **Sold prices** come from Flippa's own "recently sold" listings. Sales without a public price are excluded from comps (see `withPublicSoldPrice`).
- **Value score** needs a listing with profit data and at least 5 comparable sales with profit data. Otherwise it's left empty rather than guessed.
- **Seller-reported numbers:** revenue and profit come from sellers, and Flippa shows them rounded on its cards (e.g. $4.37K). Always do your own due diligence.
- **Removed listings** have left the marketplace without appearing among recent sales: withdrawn, expired or sold privately.
- **Proxy:** not needed normally. If a run reports that Flippa blocked it, turn on the proxy option.
- Reads Flippa's public search pages (50 listings per page) at a gentle pace. No login, no browser.
- The card parser is adapted from the open-source [2scraper/flippa-scraper](https://github.com/2scraper/flippa-scraper) (MIT License).
- Independent tool, not affiliated with Flippa.

# Actor input Schema

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

Scoring compares each listing's profit multiple with what similar businesses actually sold for on Flippa.

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

Leave empty for all types. Each type gets its own comps.

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

Auctions or fixed-price listings.

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

Order in which Flippa returns listings for sale.

## `maxListings` (type: `integer`):

How many listings to return (split across the business types).

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

Only listings asking at least this much. Also applied to the sold comps, so you compare similar-sized businesses.

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

Only listings asking at most this much.

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

Only listings with at least this monthly profit.

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

Only listings with at least this monthly revenue.

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

Only listings priced at most this many times their annual profit, e.g. 3 for 3x.

## `keywords` (type: `array`):

Only listings mentioning any of these words (title, description, type or industry), e.g. AI, newsletter, Shopify. A single keyword is also searched on Flippa directly.

## `compsSampleSize` (type: `integer`):

How many recent sold listings per business type to use as the comparison baseline (not charged).

## `trackChanges` (type: `boolean`):

Marks each listing as new or price changed since the last run, and reports listings that sold (with the sale price) or were removed.

## `onlyChanges` (type: `boolean`):

Return only new listings, price changes, and listings that sold or were removed since the last run. Turns on change tracking. Ideal for a daily schedule with email or Slack alerts.

## `memoryName` (type: `string`):

Where changes are remembered. Use different names for different searches.

## `resetMemory` (type: `boolean`):

Forget previous runs and start fresh.

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

Not needed normally. Turn on only if a run reports that Flippa blocked it (residential proxies work best).

## Actor input object example

```json
{
  "mode": "open_with_comps",
  "propertyTypes": [
    "saas",
    "website",
    "ecommerce_store"
  ],
  "saleMethod": "any",
  "sortBy": "most_recent",
  "maxListings": 500,
  "compsSampleSize": 300,
  "trackChanges": false,
  "onlyChanges": false,
  "memoryName": "flippa-monitor",
  "resetMemory": false
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("dead00/flippa-scraper-listings-sold-comps-deal-alerts").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("dead00/flippa-scraper-listings-sold-comps-deal-alerts").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 '{}' |
apify call dead00/flippa-scraper-listings-sold-comps-deal-alerts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dead00/flippa-scraper-listings-sold-comps-deal-alerts"
        }
    }
}
```

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/rFP1YI2KAAxHCBPKb/builds/F7RGfIcniozGcV82C/openapi.json