# Flippa Marketplace Scraper (`texmt/flippa-marketplace-scraper`) Actor

Scrape Flippa.com listings — price, revenue, profit, multiples, traffic, monetization, niche, and more. Perfect for deal sourcing and market research.

- **URL**: https://apify.com/texmt/flippa-marketplace-scraper.md
- **Developed by:** [Kevin](https://apify.com/texmt) (community)
- **Categories:** E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$0.01 / listing scraped

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Marketplace Scraper

**The Flippa deal-finding and market monitoring API — not just a scraper.**

Scrape [Flippa.com](https://flippa.com) listings with ROI scoring, undervaluation detection, price-drop tracking, sold-listing research, direct URL enrichment, and automatic export to Slack, Airtable, Notion, Google Sheets, and any webhook.

Built for acquisition investors, deal teams, brokers, and anyone who wants Flippa's data piped into their own workflow.

---

### Why this actor vs. the alternatives

| Feature | This actor |
|---|---|
| ROI score (0–100) with transparent formula | ✅ |
| Undervaluation flagging with per-type benchmarks | ✅ |
| Price-drop tracking across runs | ✅ |
| Sold listings research | ✅ |
| Direct URL enrichment (enrich specific listings) | ✅ |
| Mixed inputs: search filters + individual URLs in one run | ✅ |
| Confidence score (how complete is each listing's data) | ✅ |
| Flagged reasons per listing (why it was flagged) | ✅ |
| Normalized enums for type, sale method, monetization | ✅ |
| Output modes: Full / ETL / Alerts-only | ✅ |
| Native Slack, Airtable, Notion, Google Sheets, webhook | ✅ |
| Summary stats record per run | ✅ |
| Trust/badge indicators (verified, editor's choice, managed) | ✅ |
| Auction/offer state fields | ✅ |
| Traffic, domain age, seller rating | ✅ (with detail pages) |

---

### What data is extracted

#### Core fields (every listing)

| Field | Description |
|---|---|
| `url` | Direct link to the listing |
| `title` | Listing headline |
| `description` | Business description excerpt |
| `askingPrice` | Asking price (e.g. `"USD $118,000"`) |
| `monthlyProfit` | Net monthly profit (e.g. `"USD $3,956 p/mo"`) |
| `monthlyRevenue` | Monthly revenue when disclosed |
| `profitMultiple` | Valuation multiple (e.g. `"3.4x Profit"`) |
| `revenueMultiple` | Revenue multiple (e.g. `"1.2x Revenue"`) |
| `propertyType` | Normalized enum: `SaaS`, `Ecommerce`, `Amazon FBA`, `Content / Blog`, `Affiliate`, `Newsletter`, `Domain`, `App`, `Marketplace`, `Directory`, `Services`, `Forum / Community` |
| `monetizationType` | How the business makes money |
| `category` | Industry/niche |
| `listingAge` | Age of the business |
| `saleMethod` | Normalized enum: `Auction`, `Buy It Now`, `Classified` |
| `isVerified` | Verified listing badge |
| `isEditorChoice` | Editor's Choice badge |
| `isManagedByFlippa` | Managed by Flippa badge |
| `isSold` | `true` if from Flippa's sold listings section |
| `scrapedAt` | ISO timestamp |

#### ROI & analysis fields (when `roiScoring` is enabled)

| Field | Description |
|---|---|
| `roiScore` | 0–100. Higher = faster payback. 100 = under 0yr payback, 0 = 5yr+ payback |
| `paybackYears` | Asking price ÷ annual profit. Years to recoup investment |
| `isUndervalued` | `true` if payback is below the threshold for this business type |
| `roiBenchmarkUsed` | The payback threshold that determined `isUndervalued` |
| `roiExplanation` | Human-readable reason: e.g. `"Payback 2.1yr vs 3.5yr benchmark for SaaS"` |
| `confidenceScore` | 0–100. How many of the 8 key fields (price, profit, type, category, etc.) are populated |
| `flaggedReasons` | Array of reasons this listing was flagged: `undervalued`, `price_drop`, `new_listing`, `sold`, `low_confidence` |

#### Price tracking fields (when `trackPriceDrops` is enabled)

| Field | Description |
|---|---|
| `priceDropped` | `true` if price is lower than when last seen |
| `priceDrop` | Dollar amount of the reduction |
| `priceHistory` | Full price history array: `[{ price, priceNum, date }]` — one entry per price change |
| `firstSeenAt` | ISO timestamp of when this listing was first scraped |
| `lastSeenAt` | ISO timestamp of when this listing was last seen in a run |
| `relisted` | `true` if this listing was previously marked as removed and has reappeared |

#### Removal detection records (when `trackPriceDrops` is enabled)

At the end of each run, listings that were previously tracked but not seen in the current run are flagged. A record is pushed to the dataset with:

| Field | Description |
|---|---|
| `_isRemoval` | `true` — use this to identify removal event records |
| `likelyRemoved` | `true` |
| `removedAt` | ISO timestamp of when removal was detected |
| `lastSeenAt` | When it was last seen before disappearing |
| `firstSeenAt` | When it was first seen |
| `askingPrice` | Last known asking price |
| `priceHistory` | Full price history up to removal |
| `flaggedReasons` | `["likely_removed"]` |

#### Detail page fields (when `scrapeDetailPages` is enabled)

| Field | Description |
|---|---|
| `yearEstablished` | Year the business was founded |
| `sellerRating` | Seller reputation score |
| `monthlyVisitors` | Monthly traffic when disclosed |
| `annualOrganicTraffic` | Annual organic visits when disclosed |
| `domainAge` | Age of the domain (e.g. `"7 years"`) |
| `offersCount` | Number of active offers |
| `bidsCount` | Number of bids (auction listings) |
| `daysRemaining` | Days left in auction or listing window |
| `annualRevenue` | Annual revenue figure when disclosed |

#### Summary record (end of every run)

| Field | Description |
|---|---|
| `_isSummary` | `true` — use this to filter out summary records |
| `totalScraped` | Total listings saved this run |
| `undervaluedCount` | Undervalued listings count |
| `priceDropCount` | Price-drop listings count |
| `likelyRemovedCount` | Listings not seen this run, newly flagged as likely removed |
| `avgAskingPrice` | Average asking price across saved listings |
| `avgPaybackYears` | Average payback period |
| `avgConfidenceScore` | Average data completeness score |
| `typeBreakdown` | Count by normalized property type |
| `flagBreakdown` | Count by each flag reason |
| `outputMode` | Which output mode was used |
| `runCompletedAt` | ISO timestamp |

---

### ROI score explained

````

roiScore = max(0, min(100, round(100 - (paybackYears / 5) \* 100)))

````

- **100** = 0 years payback (extremely underpriced)
- **60** = 2 years payback (strong deal)
- **30** = 3.5 years payback (fair market for SaaS)
- **0** = 5+ years payback (expensive)

The `roiBenchmarkUsed` field shows the exact threshold used for `isUndervalued`, and `roiExplanation` gives a plain-English explanation for every listing.

**Per-type defaults:**

| Type | Default benchmark |
|---|---|
| SaaS | 3.5 years |
| Ecommerce / FBA | 2.5 years |
| Content / Blog / Affiliate / Newsletter | 3.0 years |
| Other | 3.0 years |

All thresholds are configurable in the actor input.

---

### Example output

```json
{
  "url": "https://flippa.com/12283554",
  "title": "GovTech SaaS — 96% margins, $29.9K revenue, evergreen webinar funnel",
  "description": "$29.9K revenue, 96% margins, custom GovTech SaaS with 1M+ B2G contact database",
  "askingPrice": "USD $114,999",
  "monthlyProfit": "USD $2,396 p/mo",
  "monthlyRevenue": null,
  "profitMultiple": "3.4x Profit",
  "revenueMultiple": "3.3x Revenue",
  "propertyType": "SaaS",
  "monetizationType": "Services & Subscriptions",
  "category": "Business",
  "listingAge": "5 years",
  "saleMethod": "Buy It Now",
  "isVerified": true,
  "isEditorChoice": false,
  "isManagedByFlippa": false,
  "isSold": false,
  "roiScore": 20,
  "paybackYears": 4.0,
  "isUndervalued": false,
  "roiBenchmarkUsed": 3.5,
  "roiExplanation": "Payback 4.0yr vs 3.5yr benchmark for SaaS",
  "confidenceScore": 87,
  "flaggedReasons": [],
  "priceDropped": false,
  "priceDrop": null,
  "firstSeenAt": "2026-03-20T09:00:00.000Z",
  "scrapedAt": "2026-04-02T04:00:00.000Z"
}
````

***

### Input options

#### Inputs & Filters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `listingUrls` | Array | `[]` | Individual Flippa listing URLs or IDs to enrich directly. Can be mixed with category filters in the same run |
| `outputMode` | Enum | `full` | `full` = all fields, `etl` = nulls stripped, `alerts` = only flagged listings |
| `propertyType` | Array | `[]` | Filter by: `website`, `fba`, `ios_app`, `android_app`, `domain`, `business`, `newsletter` |
| `siteType` | Array | `[]` | Filter by: `saas`, `ecommerce`, `content`, `blog`, `dropship`, `affiliate`, etc. |
| `minPrice` | Integer | — | Minimum asking price (USD) |
| `maxPrice` | Integer | — | Maximum asking price (USD) |
| `minMonthlyProfit` | Integer | — | Minimum monthly profit (USD) |
| `maxMonthlyProfit` | Integer | — | Maximum monthly profit (USD) |
| `minRoiScore` | Integer | — | Minimum ROI score 0–100 |
| `titleKeywords` | Array | `[]` | Only return listings whose title contains any of these keywords |
| `descriptionKeywords` | Array | `[]` | Only return listings whose description contains any of these keywords |
| `maxResults` | Integer | `50` | Maximum total listings to save (up to 1,000) |

#### ROI & Alerts

| Parameter | Type | Default | Description |
|---|---|---|---|
| `roiScoring` | Boolean | `true` | Add ROI fields to every listing |
| `onlyUndervalued` | Boolean | `false` | Only save undervalued listings |
| `undervaluedMultipleThreshold` | Number | — | Global payback override — overrides all per-type thresholds |
| `saasBenchmarkYears` | Number | `3.5` | Payback threshold for SaaS |
| `ecommerceBenchmarkYears` | Number | `2.5` | Payback threshold for Ecommerce / FBA |
| `contentBenchmarkYears` | Number | `3.0` | Payback threshold for content, blog, affiliate, newsletter |
| `defaultBenchmarkYears` | Number | `3.0` | Fallback for all other types |
| `onlyNewListings` | Boolean | `false` | Skip listings seen in previous runs |
| `includeSoldListings` | Boolean | `false` | Also scrape sold listings (tagged `isSold: true`) |
| `trackPriceDrops` | Boolean | `false` | Detect and flag price reductions across runs |
| `scrapeDetailPages` | Boolean | `false` | Visit each listing page for traffic, domain age, seller rating, auction state |

#### Integrations

| Parameter | Type | Description |
|---|---|---|
| `webhookUrl` | String | POST to this URL at end of run (Zapier, Make, n8n) |
| `slackWebhookUrl` | String | Send formatted Block Kit report to Slack |
| `airtableApiKey` | String (secret) | Airtable Personal Access Token |
| `airtableBaseId` | String | Airtable Base ID |
| `airtableTableName` | String | Table name (default: `Flippa Listings`) |
| `notionApiKey` | String (secret) | Notion Internal Integration Token |
| `notionDatabaseId` | String | Notion database ID |
| `googleServiceAccountJson` | String (secret) | Google service account JSON key |
| `googleSheetsId` | String | Google Sheets spreadsheet ID |
| `googleSheetName` | String | Sheet tab name (default: `Flippa Listings`) |

***

### Use cases

**Deal sourcing**
Find undervalued businesses matching your acquisition criteria. Set `siteType: ["saas"]`, `maxPrice: 200000`, `onlyUndervalued: true`.

**Keyword targeting**
Use `titleKeywords: ["AI", "recurring", "MRR"]` to surface only businesses matching your thesis.

**Undervalued alerts**
Schedule daily runs with `onlyUndervalued: true` + `onlyNewListings: true` + `slackWebhookUrl`. Get notified only when a new undervalued listing appears.

**Price drop alerts**
Enable `trackPriceDrops: true`. Combine with `outputMode: "alerts"` to save only listings where something changed.

**Enrich a shortlist**
Paste 10 listing URLs into `listingUrls`. Get a full structured dataset back in seconds — without manual browsing.

**Sold listings research**
Enable `includeSoldListings: true` to see what actually transacted and at what prices. Useful for benchmarking current asks.

**ETL pipeline**
Set `outputMode: "etl"` — every listing has null fields stripped, giving clean rows ready for Postgres, BigQuery, or Airtable without empty columns.

**Acquisition watchlist**
Run on a schedule with `onlyNewListings: true` + `trackPriceDrops: true`. Build a persistent history of listings you're monitoring. Each listing accumulates a full `priceHistory` array across runs. Listings that disappear from Flippa are automatically flagged as `likelyRemoved` and pushed as removal-event records. Listings that reappear after removal are flagged as `relisted` — a strong signal of a motivated seller.

***

### Output modes

| Mode | What gets saved | Best for |
|---|---|---|
| `full` | Every listing, all fields including nulls | Default, maximum data |
| `etl` | Every listing, null/empty fields removed | Databases, spreadsheets, Airtable |
| `alerts` | Only listings with at least one `flaggedReason` | Scheduled alert runs, Slack notifications |

`flaggedReasons` values: `undervalued`, `price_drop`, `relisted`, `new_listing`, `sold`, `low_confidence`, `likely_removed`

***

### Direct listing URL mode

Instead of (or in addition to) category scraping, you can pass individual listing URLs:

```json
{
  "listingUrls": [
    "https://flippa.com/12345678",
    "https://flippa.com/12283554",
    "11223344"
  ]
}
```

Bare IDs (numbers) are automatically expanded to full Flippa URLs. Each listing is fully extracted from its detail page and returns the same schema as a search-scraped listing — including ROI fields, confidence score, flagged reasons, and all trust/traffic indicators.

Mix with search filters in the same run: if you also set `siteType: ["saas"]`, the actor will scrape the SaaS category AND enrich your direct URLs in one run.

***

### Setting up the deal alert workflow

1. Set these inputs:
   - `onlyUndervalued: true`
   - `onlyNewListings: true`
   - `trackPriceDrops: true`
   - `outputMode: "alerts"`
   - `slackWebhookUrl` or `webhookUrl`
2. Tune your benchmarks (e.g. `saasBenchmarkYears: 3.0` for stricter SaaS deals)
3. Optionally add `titleKeywords: ["recurring", "MRR", "B2B"]` to narrow the niche
4. Go to **Actors → Schedules** in the Apify console and set it to run daily
5. You'll receive a Slack message only when a new undervalued or price-dropped listing appears

***

### Integrations

#### Webhook (n8n / Zapier / Make / custom)

Posts this payload at end of run:

```json
{
  "source": "flippa-marketplace-scraper",
  "runId": "abc123",
  "timestamp": "2026-04-01T00:00:00.000Z",
  "totalScraped": 50,
  "count": 50,
  "listings": [ ... ]
}
```

- **Zapier** → "Webhooks by Zapier" → "Catch Hook"
- **Make** → "Webhooks" → "Custom webhook"
- **n8n** → "Webhook" trigger node

#### Slack

Get an Incoming Webhook URL at [api.slack.com/messaging/webhooks](https://api.slack.com/messaging/webhooks). Each run sends a Block Kit formatted card with run stats and the top 5 deals by ROI score.

#### Airtable

1. Create a Personal Access Token at [airtable.com/account](https://airtable.com/account) with `data.records:write` scope
2. Create a table named **Flippa Listings** with these columns:

| Column | Type |
|---|---|
| Title | Single line text |
| URL | URL |
| Asking Price | Single line text |
| Monthly Profit | Single line text |
| Monthly Revenue | Single line text |
| Profit Multiple | Single line text |
| Revenue Multiple | Single line text |
| Type | Single line text |
| Monetization | Single line text |
| Category | Single line text |
| Listing Age | Single line text |
| Sale Method | Single line text |
| Description | Long text |
| Scraped At | Single line text |
| ROI Score | Number |
| Payback (yrs) | Number |
| Undervalued | Checkbox |
| Confidence Score | Number |
| Price Dropped | Checkbox |
| Price Drop ($) | Number |
| Sold | Checkbox |

3. Find your Base ID at `airtable.com/developers/web/api/introduction`

#### Notion

1. Go to [notion.so/my-integrations](https://www.notion.so/my-integrations) → New integration → copy the Internal Integration Token
2. Create a database with matching properties (see Airtable table above for field names/types; use Select for Type, Monetization, Category, Sale Method)
3. Share the database with your integration (··· → Connections)
4. Copy the database ID from the URL

#### Google Sheets

1. Enable the Sheets API at [console.cloud.google.com](https://console.cloud.google.com) → create a Service Account → download JSON key
2. Share your sheet with the service account email (Editor access)
3. Paste the full JSON into `googleServiceAccountJson`
4. Copy the spreadsheet ID from the URL

The actor writes a header row on the first run, then appends rows on subsequent runs.

***

### Pricing

**$0.01 per listing** — flat rate, all features included.

- 50 listings = $0.50
- 500 listings = $5.00
- 1,000 listings = $10.00

Apify platform usage (compute + residential proxy bandwidth) is billed separately. Most runs of 50–200 listings cost under $0.50 in platform fees.

***

### Tips

- Leave all filters empty + set `maxResults: 200` for a broad market sweep
- Combine `siteType: ["saas"]` + `maxPrice: 100000` + `minRoiScore: 50` to instantly surface fast-payback SaaS under $100K
- `outputMode: "etl"` is the cleanest option for piping data into databases — no empty columns
- Use `listingUrls` to enrich a specific shortlist without running a full category scrape
- Enable `scrapeDetailPages` only when you need traffic/domain/seller data — it roughly doubles run time
- `trackPriceDrops` is most useful on a recurring schedule — the first run just stores baseline prices
- Use `confidenceScore` to filter out listings where Flippa hides key data behind NDA: `minConfidenceScore` isn't an input filter yet, but you can post-filter in your downstream tool

***

### Notes

- Revenue and profit figures marked "Confidential" by sellers on Flippa are not accessible and are not scraped
- Residential proxies are required — Flippa blocks datacenter IPs on its listing routes
- Sold listing prices populate the `askingPrice` field (Flippa shows sale price in the same position)
- Flippa's site structure may change; if fields stop populating, leave a review and we'll update selectors
- The `_isSummary: true` record at the end of each dataset is a run-level stats row — filter it out in downstream tools if needed

# Actor input Schema

## `listingUrls` (type: `array`):

Paste individual Flippa listing URLs or IDs to enrich directly (e.g. "https://flippa.com/12345678" or just "12345678"). Can be used alone or combined with category filters in one run. All listings return the same schema.

## `outputMode` (type: `string`):

Controls what gets saved to the dataset. 'full' = every listing with all fields. 'etl' = same listings but null/empty fields stripped (clean for Sheets/Airtable/Postgres). 'alerts' = only listings with at least one flaggedReason (undervalued, price\_drop, new\_listing, sold, low\_confidence).

## `propertyType` (type: `array`):

Filter by type of business/asset. Leave empty to scrape all categories.

## `siteType` (type: `array`):

Filter by business model. Multiple selections each scrape their own category page.

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

Only return listings at or above this asking price

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

Only return listings at or below this asking price

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

Only return listings with at least this monthly net profit

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

Only return listings with at most this monthly net profit

## `minRoiScore` (type: `integer`):

Only return listings at or above this ROI score. 100 = best deal (fastest payback), 0 = worst. Requires ROI Scoring to be enabled.

## `titleKeywords` (type: `array`):

Only return listings whose title contains at least one of these keywords (case-insensitive). E.g. \["AI", "SaaS", "recurring"]. Leave empty to match all titles.

## `descriptionKeywords` (type: `array`):

Only return listings whose description contains at least one of these keywords (case-insensitive). Useful for niche targeting. Leave empty to match all.

## `maxResults` (type: `integer`):

Maximum total listings to scrape across all selected categories

## `roiScoring` (type: `boolean`):

Add roiScore (0–100), paybackYears, and isUndervalued to every listing.

## `onlyUndervalued` (type: `boolean`):

When enabled, only listings flagged as undervalued (payback period below the threshold) are saved. Ideal for alert-style scheduled runs.

## `undervaluedMultipleThreshold` (type: `number`):

If set, ALL business types use this payback threshold. Leave empty to use per-type thresholds (SaaS, Ecommerce, Content) set below.

## `saasBenchmarkYears` (type: `number`):

Payback threshold for SaaS businesses. Default: 3.5 years. Ignored if Global Override is set.

## `ecommerceBenchmarkYears` (type: `number`):

Payback threshold for Ecommerce and Amazon FBA businesses. Default: 2.5 years. Ignored if Global Override is set.

## `contentBenchmarkYears` (type: `number`):

Payback threshold for content, blog, affiliate, and newsletter businesses. Default: 3.0 years. Ignored if Global Override is set.

## `defaultBenchmarkYears` (type: `number`):

Fallback payback threshold for business types not matched above. Default: 3.0 years. Ignored if Global Override is set.

## `onlyNewListings` (type: `boolean`):

Skip listings seen in previous runs. Uses a persistent store to track seen listing IDs across runs. Perfect for scheduled daily/weekly alerts.

## `includeSoldListings` (type: `boolean`):

Also scrape Flippa's /sold pages alongside active listings. Sold listings are tagged with isSold: true. Useful for market research on actual transaction prices.

## `trackPriceDrops` (type: `boolean`):

Compare each listing's current asking price against the price stored from previous runs. Listings with a lower price are flagged with priceDropped: true and priceDrop: <USD amount dropped>. Best combined with scheduled runs.

## `scrapeDetailPages` (type: `boolean`):

Visit each listing's page for extra fields: verified status, editor's choice badge, seller rating, year established, monthly visitors.

## `webhookUrl` (type: `string`):

POST all saved listings to this URL at the end of each run. Works with Zapier, Make, n8n, or any HTTP endpoint.

## `slackWebhookUrl` (type: `string`):

Incoming Webhook URL from Slack. Sends a formatted Block Kit deal report at the end of each run. Get yours at api.slack.com/messaging/webhooks.

## `airtableApiKey` (type: `string`):

Personal Access Token from airtable.com/account. Required for Airtable export.

## `airtableBaseId` (type: `string`):

The Base ID from your Airtable URL (e.g. appXXXXXXXXXXXXXX).

## `airtableTableName` (type: `string`):

Name of the table in your Airtable base where listings will be written.

## `notionApiKey` (type: `string`):

Internal Integration Token from notion.so/my-integrations. The integration must have access to your target database.

## `notionDatabaseId` (type: `string`):

The 32-character ID from your Notion database URL. Share the database with your integration first.

## `googleServiceAccountJson` (type: `string`):

Full JSON contents of a Google service account key file with Sheets API access. Create at console.cloud.google.com → IAM → Service Accounts → Keys. Share your sheet with the service account email.

## `googleSheetsId` (type: `string`):

The ID from your Google Sheets URL: docs.google.com/spreadsheets/d/<ID>/edit

## `googleSheetName` (type: `string`):

Name of the tab/sheet within the spreadsheet where data will be appended.

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

Residential proxies are required — Flippa blocks datacenter IPs on its search routes.

## Actor input object example

```json
{
  "listingUrls": [],
  "outputMode": "full",
  "propertyType": [],
  "siteType": [],
  "titleKeywords": [],
  "descriptionKeywords": [],
  "maxResults": 50,
  "roiScoring": true,
  "onlyUndervalued": false,
  "saasBenchmarkYears": 3.5,
  "ecommerceBenchmarkYears": 2.5,
  "contentBenchmarkYears": 3,
  "defaultBenchmarkYears": 3,
  "onlyNewListings": false,
  "includeSoldListings": false,
  "trackPriceDrops": false,
  "scrapeDetailPages": false,
  "airtableTableName": "Flippa Listings",
  "googleSheetName": "Flippa Listings",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("texmt/flippa-marketplace-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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    } }

# Run the Actor and wait for it to finish
run = client.actor("texmt/flippa-marketplace-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call texmt/flippa-marketplace-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=texmt/flippa-marketplace-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flippa Marketplace Scraper",
        "description": "Scrape Flippa.com listings — price, revenue, profit, multiples, traffic, monetization, niche, and more. Perfect for deal sourcing and market research.",
        "version": "1.0",
        "x-build-id": "1YO0PEVXZhkj7ZsDq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/texmt~flippa-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-texmt-flippa-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/texmt~flippa-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-texmt-flippa-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/texmt~flippa-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-texmt-flippa-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "listingUrls": {
                        "title": "Direct Listing URLs",
                        "type": "array",
                        "description": "Paste individual Flippa listing URLs or IDs to enrich directly (e.g. \"https://flippa.com/12345678\" or just \"12345678\"). Can be used alone or combined with category filters in one run. All listings return the same schema.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "outputMode": {
                        "title": "Output Mode",
                        "enum": [
                            "full",
                            "etl",
                            "alerts"
                        ],
                        "type": "string",
                        "description": "Controls what gets saved to the dataset. 'full' = every listing with all fields. 'etl' = same listings but null/empty fields stripped (clean for Sheets/Airtable/Postgres). 'alerts' = only listings with at least one flaggedReason (undervalued, price_drop, new_listing, sold, low_confidence).",
                        "default": "full"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "type": "array",
                        "description": "Filter by type of business/asset. Leave empty to scrape all categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "website",
                                "fba",
                                "ios_app",
                                "android_app",
                                "domain",
                                "business",
                                "newsletter"
                            ],
                            "enumTitles": [
                                "Website",
                                "Amazon FBA",
                                "iOS App",
                                "Android App",
                                "Domain",
                                "Business",
                                "Newsletter"
                            ]
                        },
                        "default": []
                    },
                    "siteType": {
                        "title": "Site Type / Business Model",
                        "type": "array",
                        "description": "Filter by business model. Multiple selections each scrape their own category page.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "saas",
                                "ecommerce",
                                "content",
                                "blog",
                                "dropship",
                                "digital-products",
                                "shopify",
                                "affiliate",
                                "marketplace",
                                "forum-community",
                                "directory",
                                "services"
                            ],
                            "enumTitles": [
                                "SaaS",
                                "Ecommerce",
                                "Content",
                                "Blog",
                                "Dropshipping",
                                "Digital Products",
                                "Shopify",
                                "Affiliate",
                                "Marketplace",
                                "Forum / Community",
                                "Directory",
                                "Services"
                            ]
                        },
                        "default": []
                    },
                    "minPrice": {
                        "title": "Minimum Asking Price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings at or above this asking price"
                    },
                    "maxPrice": {
                        "title": "Maximum Asking Price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings at or below this asking price"
                    },
                    "minMonthlyProfit": {
                        "title": "Minimum Monthly Profit (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with at least this monthly net profit"
                    },
                    "maxMonthlyProfit": {
                        "title": "Maximum Monthly Profit (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with at most this monthly net profit"
                    },
                    "minRoiScore": {
                        "title": "Minimum ROI Score (0–100)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only return listings at or above this ROI score. 100 = best deal (fastest payback), 0 = worst. Requires ROI Scoring to be enabled."
                    },
                    "titleKeywords": {
                        "title": "Title Keywords",
                        "type": "array",
                        "description": "Only return listings whose title contains at least one of these keywords (case-insensitive). E.g. [\"AI\", \"SaaS\", \"recurring\"]. Leave empty to match all titles.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "descriptionKeywords": {
                        "title": "Description Keywords",
                        "type": "array",
                        "description": "Only return listings whose description contains at least one of these keywords (case-insensitive). Useful for niche targeting. Leave empty to match all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum total listings to scrape across all selected categories",
                        "default": 50
                    },
                    "roiScoring": {
                        "title": "ROI Scoring",
                        "type": "boolean",
                        "description": "Add roiScore (0–100), paybackYears, and isUndervalued to every listing.",
                        "default": true
                    },
                    "onlyUndervalued": {
                        "title": "Only Return Undervalued Listings",
                        "type": "boolean",
                        "description": "When enabled, only listings flagged as undervalued (payback period below the threshold) are saved. Ideal for alert-style scheduled runs.",
                        "default": false
                    },
                    "undervaluedMultipleThreshold": {
                        "title": "Undervalued Threshold — Global Override (Years Payback)",
                        "minimum": 0.5,
                        "maximum": 10,
                        "type": "number",
                        "description": "If set, ALL business types use this payback threshold. Leave empty to use per-type thresholds (SaaS, Ecommerce, Content) set below."
                    },
                    "saasBenchmarkYears": {
                        "title": "SaaS Undervalued Threshold (Years Payback)",
                        "minimum": 0.5,
                        "maximum": 10,
                        "type": "number",
                        "description": "Payback threshold for SaaS businesses. Default: 3.5 years. Ignored if Global Override is set.",
                        "default": 3.5
                    },
                    "ecommerceBenchmarkYears": {
                        "title": "Ecommerce / FBA Undervalued Threshold (Years Payback)",
                        "minimum": 0.5,
                        "maximum": 10,
                        "type": "number",
                        "description": "Payback threshold for Ecommerce and Amazon FBA businesses. Default: 2.5 years. Ignored if Global Override is set.",
                        "default": 2.5
                    },
                    "contentBenchmarkYears": {
                        "title": "Content / Blog / Affiliate Undervalued Threshold (Years Payback)",
                        "minimum": 0.5,
                        "maximum": 10,
                        "type": "number",
                        "description": "Payback threshold for content, blog, affiliate, and newsletter businesses. Default: 3.0 years. Ignored if Global Override is set.",
                        "default": 3
                    },
                    "defaultBenchmarkYears": {
                        "title": "Default Undervalued Threshold (Years Payback)",
                        "minimum": 0.5,
                        "maximum": 10,
                        "type": "number",
                        "description": "Fallback payback threshold for business types not matched above. Default: 3.0 years. Ignored if Global Override is set.",
                        "default": 3
                    },
                    "onlyNewListings": {
                        "title": "Only New Listings (Alert Mode)",
                        "type": "boolean",
                        "description": "Skip listings seen in previous runs. Uses a persistent store to track seen listing IDs across runs. Perfect for scheduled daily/weekly alerts.",
                        "default": false
                    },
                    "includeSoldListings": {
                        "title": "Include Sold Listings",
                        "type": "boolean",
                        "description": "Also scrape Flippa's /sold pages alongside active listings. Sold listings are tagged with isSold: true. Useful for market research on actual transaction prices.",
                        "default": false
                    },
                    "trackPriceDrops": {
                        "title": "Track Price Drops",
                        "type": "boolean",
                        "description": "Compare each listing's current asking price against the price stored from previous runs. Listings with a lower price are flagged with priceDropped: true and priceDrop: <USD amount dropped>. Best combined with scheduled runs.",
                        "default": false
                    },
                    "scrapeDetailPages": {
                        "title": "Scrape Detail Pages",
                        "type": "boolean",
                        "description": "Visit each listing's page for extra fields: verified status, editor's choice badge, seller rating, year established, monthly visitors.",
                        "default": false
                    },
                    "webhookUrl": {
                        "title": "Webhook URL (n8n / Zapier / Make / custom)",
                        "type": "string",
                        "description": "POST all saved listings to this URL at the end of each run. Works with Zapier, Make, n8n, or any HTTP endpoint."
                    },
                    "slackWebhookUrl": {
                        "title": "Slack Webhook URL",
                        "type": "string",
                        "description": "Incoming Webhook URL from Slack. Sends a formatted Block Kit deal report at the end of each run. Get yours at api.slack.com/messaging/webhooks."
                    },
                    "airtableApiKey": {
                        "title": "Airtable API Key",
                        "type": "string",
                        "description": "Personal Access Token from airtable.com/account. Required for Airtable export."
                    },
                    "airtableBaseId": {
                        "title": "Airtable Base ID",
                        "type": "string",
                        "description": "The Base ID from your Airtable URL (e.g. appXXXXXXXXXXXXXX)."
                    },
                    "airtableTableName": {
                        "title": "Airtable Table Name",
                        "type": "string",
                        "description": "Name of the table in your Airtable base where listings will be written.",
                        "default": "Flippa Listings"
                    },
                    "notionApiKey": {
                        "title": "Notion Integration Token",
                        "type": "string",
                        "description": "Internal Integration Token from notion.so/my-integrations. The integration must have access to your target database."
                    },
                    "notionDatabaseId": {
                        "title": "Notion Database ID",
                        "type": "string",
                        "description": "The 32-character ID from your Notion database URL. Share the database with your integration first."
                    },
                    "googleServiceAccountJson": {
                        "title": "Google Service Account JSON",
                        "type": "string",
                        "description": "Full JSON contents of a Google service account key file with Sheets API access. Create at console.cloud.google.com → IAM → Service Accounts → Keys. Share your sheet with the service account email."
                    },
                    "googleSheetsId": {
                        "title": "Google Sheets Spreadsheet ID",
                        "type": "string",
                        "description": "The ID from your Google Sheets URL: docs.google.com/spreadsheets/d/<ID>/edit"
                    },
                    "googleSheetName": {
                        "title": "Google Sheet Tab Name",
                        "type": "string",
                        "description": "Name of the tab/sheet within the spreadsheet where data will be appended.",
                        "default": "Flippa Listings"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxies are required — Flippa blocks datacenter IPs on its search routes."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
