# FLIPPA.com $0.8💰 URL | Filters | Enriched Output (`abotapi/flippa-com-scraper`) Actor

From $0.8/1K. Scrape FLIPPA.com with full enrichment. Extract profit, revenue, multiples, traffic, age, location, monetization, badges, and more. Combines search JSON and listing API data. Supports filters or URL input, concurrent enrichment, and fast, low-resource runs.

- **URL**: https://apify.com/abotapi/flippa-com-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** E-commerce, Lead generation, Developer tools
- **Stats:** 1 total users, 1 monthly users, 90.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Flippa Scraper

Pull every public field from flippa.com listings, fast and cheap. Search by filters or paste any URL. Each record carries 80+ structured fields plus the raw upstream payload, so you never lose data the platform exposes.

### Why This Scraper?

- **Complete output:** monthly profit, monthly revenue, profit and revenue multiples, page views, uniques, site age, seller location, monetization, sale method, verifications, badges, integrations, all preserved.
- **Record sources:** the search-results JSON island for badges, multiples, key data, and price text; pasted listing URLs read the public listing page directly (the site's anonymous listings API stopped answering in 2026-09; it is kept only as an automatic fallback).
- **Search and URL mode:** filter by 25 dimensions, or paste search URLs and listing URLs straight from your browser.
- **Concurrent enrichment:** detail data fetched in parallel and pushed per record, so an aborted run still keeps everything that finished.
- **Free-tier friendly:** the default Apify proxy works, no residential needed.
- **Lean and fast:** ~50 MB peak memory, sub-second cold start, low compute usage.
- **Daily/recurring change monitoring:** turn on Incremental mode to get only NEW, UPDATED, and REAPPEARED listings on every scheduled run, or resume one specific interrupted crawl with `resumeFromRunId`.

### Data You Get

> Sample shape, values are illustrative placeholders, not from a live listing.

| Field | Example |
|---|---|
| `id` | `"00000000"` |
| `url` | `"https://flippa.com/00000000-sample-slug"` |
| `title` | `"Sample listing title"` |
| `summary` | `"Brief seller pitch text shown on the search card."` |
| `propertyName` | `"example.com"` |
| `hostname` | `"example.com"` |
| `externalUrl` | `"https://www.example.com/"` |
| `propertyType` | `"saas"` |
| `siteType` | `"AiAppsAndTools"` |
| `category` | `"Internet"` |
| `monetization` | `"Ads"` |
| `primaryPlatform` | `"Open AI"` |
| `industry` | `"internet"` |
| `businessModel` | `null` |
| `saleMethod` | `"classified"` |
| `saleMethodTitle` | `"Asking Price"` |
| `status` | `"open"` |
| `endAt` | `"2026-01-01T00:00:00+00:00"` |
| `price` | `0` |
| `originalPrice` | `0` |
| `priceText` | `"USD $0"` |
| `priceDropped` | `false` |
| `priceDroppedPercent` | `0` |
| `currency` | `"USD"` |
| `monthlyRevenue` | `0` |
| `monthlyProfit` | `0` |
| `annualRevenue` | `0` |
| `annualProfit` | `0` |
| `revenuePerMonth` | `0` |
| `profitPerMonth` | `0` |
| `profitMultiple` | `0.0` |
| `revenueMultiple` | `0.0` |
| `uniquesPerMonth` | `0` |
| `pageViewsPerMonth` | `0` |
| `annualOrganicTraffic` | `0` |
| `authorityScore` | `0` |
| `siteAge` | `"1 year"` |
| `ageInYears` | `"1 year"` |
| `ageInMonths` | `12` |
| `businessLocation` | `"WY, United States"` |
| `sellerLocation` | `"United States"` |
| `revenueSources` | `[]` |
| `isVerifiedRevenue` | `false` |
| `isVerifiedTraffic` | `true` |
| `isManuallyVetted` | `true` |
| `isEditorsChoice` | `false` |
| `isSuperSeller` | `false` |
| `isSponsored` | `false` |
| `bidCount` | `0` |
| `thumbnailUrl` | `"https://static.flippa.com/assets/sample-placeholder.svg"` |
| `keyData` | `[{ "label": "Type", "value": "Sample" }]` |
| `badges` | `[]` |
| `allVerifications` | `[]` |
| `integrations` | `["google_analytics"]` |
| `raw` | full search-card object preserved verbatim |
| `apiRaw` | full listings JSON:API record preserved verbatim |
| `changeType` | `"NEW"` (incremental mode only — see "Resume & recurring updates" below) |
| `changedFields` | `["price", "status"]` (incremental mode, `UPDATED` rows only) |
| `firstSeenAt` | `"2026-08-01T00:00:00Z"` (incremental mode only) |
| `lastSeenAt` | `"2026-08-05T00:00:00Z"` (incremental mode only) |

### How to Use

#### Search by filters

```json
{
  "mode": "search",
  "status": ["open"],
  "propertyTypes": ["saas", "ai_apps_and_tools"],
  "saleMethods": ["classified"],
  "sortBy": "most_recent",
  "minPrice": 1000,
  "maxPrice": 50000,
  "minMonthlyProfit": 100,
  "fetchDetails": true,
  "maxListings": 50,
  "maxPages": 5
}
```

#### Verified-revenue ecommerce, US sellers

```json
{
  "mode": "search",
  "propertyTypes": ["ecommerce_store"],
  "verifiedRevenueOnly": true,
  "sellerLocation": "us",
  "fetchDetails": true,
  "maxListings": 100
}
```

#### Paste any flippa.com URLs

```json
{
  "mode": "url",
  "urls": [
    "https://flippa.com/search?search_template=most_relevant&filter%5Bstatus%5D=open&filter%5Bproperty_type%5D=saas",
    "https://flippa.com/search?search_template=most_recent&filter%5Bsale_method%5D=auction&filter%5Bstatus%5D=open",
    "https://flippa.com/12345678"
  ],
  "fetchDetails": true,
  "maxListings": 60
}
```

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` to filter, or `url` to paste URLs. |
| `status` | array | `["open"]` | `open` for live, `won` for recently sold, both supported. |
| `propertyTypes` | array | (any) | website, fba, saas, ecommerce\_store, ai\_apps\_and\_tools, plugin\_and\_extension, youtube, ios\_app, android\_app, game, crypto\_app, social\_media, newsletter, service\_and\_agency, service, projects\_and\_concepts, domain, other. |
| `siteTypes` | array | (any) | Granular site type within an asset type. |
| `saleMethods` | array | (any) | `auction`, `classified`. |
| `sortBy` | string | `most_relevant` | `most_relevant`, `most_recent`, `ending_soonest`, `most_active`. |
| `minPrice` / `maxPrice` | integer | (none) | Asking price range in USD. |
| `minMonthlyProfit` / `maxMonthlyProfit` | integer | (none) | Monthly net profit range. |
| `minMonthlyRevenue` / `maxMonthlyRevenue` | integer | (none) | Monthly revenue range. |
| `minUniquesPerMonth` | integer | (none) | Minimum monthly uniques. |
| `minAgeMonths` / `maxAgeMonths` | integer | (none) | Age range in months. |
| `tlds` | array | (any) | Domain extensions (com, org, io, ai, app, ...). |
| `sellerLocation` | string | (any) | ISO country code (us, gb, au) or region (afr, nam, sam, asi, eeu, weu, oce). |
| `verifiedRevenueOnly` | boolean | `false` | Only verified-revenue listings. |
| `verifiedTrafficOnly` | boolean | `false` | Only verified-traffic listings. |
| `manuallyVettedOnly` | boolean | `false` | Only manually vetted listings. |
| `editorsChoiceOnly` | boolean | `false` | Editor's Choice only. |
| `superSellerOnly` | boolean | `false` | Super Seller only. |
| `brokerSellerOnly` | boolean | `false` | Brokered listings only. |
| `sponsoredOnly` | boolean | `false` | Sponsored listings only. |
| `buyItNowOnly` | boolean | `false` | Buy It Now auctions only. |
| `reserveMetOnly` | boolean | `false` | Reserve met auctions only. |
| `priceDroppedOnly` | boolean | `false` | Price reduced only. |
| `managedByFlippaOnly` | boolean | `false` | Managed by Flippa only. |
| `earlyAccessOnly` | boolean | `false` | First Access only. |
| `revenueGenerating` | string | `any` | `yes`, `no`, or `any`. |
| `urls` | array | (none) | URL-mode input, supports search and listing URLs. |
| `fetchDetails` | boolean | `true` | Enriches each record from the listing's public detail page (asking-price detail, monthly profit/revenue, multiples, seller location, site age, page views). A few fields the site's old anonymous API used to add (hostname, external URL, business model, revenue sources) are no longer offered anonymously and stay null. |
| `maxListings` | integer | `20` | Hard cap on dataset items — this is the actor's only finite default limit. `0` means unlimited (bounded only by `maxPages` and Flippa's own ~10,000-listing ceiling). |
| `maxPages` | integer | `0` | Pages to walk per search URL (25 listings/page). `0` walks the whole result set for that search — see [Pagination and the "walk the whole catalogue" default](#pagination-and-the-walk-the-whole-catalogue-default) below. A positive number caps pages explicitly. |
| `resumeFromRunId` | string | (none) | Continue one specific previous run/dataset: listings already collected there are skipped, so this run returns only new listings. For recurring monitoring of the same search, use `incrementalMode` instead — see [Resume & recurring updates](#resume--recurring-updates) below. |
| `incrementalMode` | boolean | `false` | Recurring monitoring of this same search. First run returns everything as `NEW`; later runs return only `NEW`/`UPDATED`/`REAPPEARED` by default. See [Resume & recurring updates](#resume--recurring-updates) below. |
| `stateKey` | string | (none) | Optional name for a monitoring campaign, so its incremental state stays stable or is deliberately shared. Auto-derived from your filters and `fetchDetails` setting when left empty. |
| `emitUnchanged` | boolean | `false` | Incremental mode only. Also return listings unchanged since the last run, marked `UNCHANGED`. Adds and bills extra rows you already have. |
| `emitExpired` | boolean | `false` | Incremental mode only. Also return listings from a previous run no longer found, marked `EXPIRED`, once a run has fully scanned the search (not capped, not a resume). Adds and bills extra synthetic rows. |
| `proxy` | object | Apify default | Default works fine, residential is optional. |

#### Pagination and the "walk the whole catalogue" default

`maxPages: 0` (the default) does **not** mean "no results" — it means the actor walks pages until one of the run's real terminators is hit:

- the result total Flippa's own API reports for that search (`metadata.totalResults`) — a narrow filter naturally ends after a handful of pages;
- Flippa's genuine site ceiling of **25 listings/page × 400 pages = ~10,000 results per search**, which is a real limit of Flippa's `/search` API, not a limit the actor imposes;
- an empty page or a page that returns only listings already seen.

`maxListings` (default `20`) is the actor's **sole finite soft cap** — it bounds how many listings a default run pushes without you having to think about pages at all. Set `maxListings: 0` to opt into pulling the full result set (still bounded by the terminators above), or set `maxPages` to a positive number to cap pages explicitly instead.

### Resume & recurring updates

There are two different things here — pick the one that matches what you're doing:

| Need | Use |
| --- | --- |
| A crawl stopped and should continue | `resumeFromRunId` / automatic checkpoint recovery |
| Run the same search on a schedule and receive only changes | `incrementalMode` |
| Keep separate recurring campaigns for similar searches | distinct `stateKey` values |
| Run a normal full snapshot | leave both off |

**Resume** (`resumeFromRunId`) continues one specific interrupted or previous large pull: paste a run ID or dataset ID and this run skips listings already collected there, returning only the remaining new ones. The actor reads the prior dataset's `id` field and fails fast before scraping if the ID doesn't resolve to a readable run or dataset. Combine both runs' datasets for the complete set. An automatic same-run checkpoint also protects against platform migrations/resurrects without any input needed — a `maxPages: 0` / `maxListings: 0` full pull picks up where it left off after a migration or a manual **Resurrect**, same dataset, no duplicate listings, no double charges.

**Incremental mode** (`incrementalMode`) is for a schedule (for example, daily or weekly): the actor remembers the previous run of the *same* search by itself, so you never paste a run ID. The first run returns everything as `NEW`. Later runs return only `NEW`, `UPDATED`, and `REAPPEARED` listings by default — duplicates and unchanged listings are suppressed (and not charged). Turn on `emitUnchanged` or `emitExpired` only when you also want those rows returned (and billed for). `EXPIRED` rows are only returned once a run proves it covered the whole tracked search — a capped, resumed, or otherwise partial run keeps the previous state as-is instead of guessing. State is isolated per search filter and per `fetchDetails` setting automatically; set `stateKey` to name or deliberately share a monitoring campaign. Every field is returned on every row regardless of mode — incremental mode only adds the four `changeType`/`changedFields`/`firstSeenAt`/`lastSeenAt` columns on top, nothing is held back.

Scheduled-run example — same search, run daily:

Day 1 (first run ever for this search):

```json
{ "mode": "search", "propertyTypes": ["saas"], "verifiedRevenueOnly": true, "incrementalMode": true }
```

→ every listing comes back with `"changeType": "NEW"`.

Day 2 (the schedule fires again, identical input):

```json
{ "mode": "search", "propertyTypes": ["saas"], "verifiedRevenueOnly": true, "incrementalMode": true }
```

→ listings that vanished or reappeared come back as `"changeType": "REAPPEARED"`, listings whose price/status/etc. changed come back as `"changeType": "UPDATED"` with `changedFields` listing what changed, brand-new listings come back as `"changeType": "NEW"` — and listings that are still there, unchanged, are **not** returned at all (suppressed, not charged) unless `emitUnchanged` is on.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape — the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record — not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Output Example

> Sample shape, placeholder values.

```json
{
  "id": "00000000",
  "url": "https://flippa.com/00000000-sample-slug",
  "title": "Sample SaaS listing with passive monthly revenue",
  "summary": "Brief seller pitch text shown on the search card.",
  "propertyName": "example.com",
  "hostname": "example.com",
  "externalUrl": "https://www.example.com/",
  "propertyType": "saas",
  "siteType": "AiAppsAndTools",
  "category": "Internet",
  "monetization": "Subscription",
  "primaryPlatform": "Open AI",
  "industry": "internet",
  "businessModel": null,
  "saleMethod": "classified",
  "saleMethodTitle": "Asking Price",
  "status": "open",
  "endAt": "2026-01-01T00:00:00+00:00",
  "price": 0,
  "originalPrice": 0,
  "priceText": "USD $0",
  "priceDropped": false,
  "currency": "USD",
  "monthlyRevenue": 0,
  "monthlyProfit": 0,
  "annualRevenue": 0,
  "annualProfit": 0,
  "profitMultiple": 0,
  "revenueMultiple": 0,
  "uniquesPerMonth": 0,
  "pageViewsPerMonth": 0,
  "annualOrganicTraffic": 0,
  "authorityScore": 0,
  "siteAge": "1 year",
  "ageInYears": "1 year",
  "ageInMonths": 12,
  "businessLocation": "WY, United States",
  "sellerLocation": "United States",
  "revenueSources": [],
  "isVerifiedRevenue": false,
  "isVerifiedTraffic": true,
  "isManuallyVetted": true,
  "isEditorsChoice": false,
  "isSuperSeller": false,
  "isSponsored": false,
  "bidCount": 0,
  "thumbnailUrl": "https://static.flippa.com/assets/sample-placeholder.svg",
  "keyData": [
    { "label": "Type", "value": "Sample" },
    { "label": "Industry", "value": "Internet" }
  ],
  "badges": [],
  "allVerifications": [],
  "integrations": ["google_analytics"],
  "raw": { "/* full search-card object */": "..." },
  "apiRaw": { "/* full listings JSON:API record */": "..." }
}
```

### Plan Requirement

- The default Apify proxy works for flippa.com, so the Free plan is enough to run this scraper.
- Residential is supported but rarely needed. Use it only if you observe rotation pressure on very large jobs.
- Detail enrichment makes one extra HTTP call per listing. Turn it off if you only need the search-card shape.

### Verification

- 2026-09-01: re-audited against the live site. Filter narrowing re-derived server-side from the search's own result total: open 10,000 (site ceiling), +SaaS 745, +price $1k-50k 427 (25/25 page-1 prices in band), +verified revenue 94, auctions 712, monthly-profit $500-2k 964 (page-1 profits in band), US sellers all-US page 1, .com/.io TLD totals 1,565-10,000 with visible .io hostnames, most\_recent vs ending\_soonest give distinct server orderings. Fixed: the site's anonymous listings API started returning 401, which had zeroed pasted listing URLs and silently dropped a few enrichment fields; listing URLs now read the public listing page (real record: title, asking $436,829 was $927,250 reduced 53%, France, 3 years, EUR 11,333/mo profit, 2.8x multiple) with the API kept as fallback, and enrichment stops retrying the dead API after its first deterministic refusal.

# Actor input Schema

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

Pick how to find listings. Search builds URLs from filters. URL mode pastes ready-made flippa.com URLs.

## `status` (type: `array`):

Open auctions/classifieds, recently sold, or both.

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

Asset types. Leave empty to include all. Pick any of: website, fba, saas, ecommerce\_store, plugin\_and\_extension, ai\_apps\_and\_tools, youtube, ios\_app, android\_app, game, crypto\_app, social\_media, newsletter, service\_and\_agency, service, projects\_and\_concepts, domain, other.

## `siteTypes` (type: `array`):

Granular site type within an asset type. Examples: BrowserExtension, ShopifyPlugin, WordpressPlugin, AiAppsAndTools, Newsletter, SocialMedia, Youtube, CryptoApp, MarketingAgency, SoftwareDevelopmentAgency, ContentAndMediaProject, MobileAppProject, SaasAndSoftwareProject, OtherProject. Leave empty for any.

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

Auction or Classified (asking price). Leave empty for both.

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

Sort order for results.

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

Minimum asking price. Leave empty for no minimum.

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

Maximum asking price. Leave empty for no maximum.

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

Minimum monthly net profit. Leave empty for no minimum.

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

Maximum monthly net profit. Leave empty for no maximum.

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

Minimum monthly revenue. Leave empty for no minimum.

## `maxMonthlyRevenue` (type: `integer`):

Maximum monthly revenue. Leave empty for no maximum.

## `minUniquesPerMonth` (type: `integer`):

Minimum monthly unique visitors. Leave empty for no minimum.

## `minAgeMonths` (type: `integer`):

Minimum age in months. Leave empty for no minimum.

## `maxAgeMonths` (type: `integer`):

Maximum age in months. Leave empty for no maximum.

## `tlds` (type: `array`):

Limit to specific domain extensions. Examples: com, org, net, io, co, ai, app. Leave empty for any.

## `sellerLocation` (type: `string`):

ISO 2-letter country code (e.g. us, gb, au) or region code (afr, nam, sam, asi, eeu, weu, oce). Leave empty for any.

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

Only listings with Flippa-verified revenue.

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

Only listings with Flippa-verified traffic.

## `manuallyVettedOnly` (type: `boolean`):

Only listings the Flippa team or broker has manually vetted.

## `editorsChoiceOnly` (type: `boolean`):

Only Editor's Choice listings.

## `superSellerOnly` (type: `boolean`):

Only listings from Super Sellers.

## `brokerSellerOnly` (type: `boolean`):

Only brokered listings.

## `sponsoredOnly` (type: `boolean`):

Only sponsored (premium) listings.

## `buyItNowOnly` (type: `boolean`):

Auctions with Buy It Now option.

## `reserveMetOnly` (type: `boolean`):

Auctions where the reserve has been met.

## `priceDroppedOnly` (type: `boolean`):

Listings whose price has been reduced.

## `managedByFlippaOnly` (type: `boolean`):

Only listings managed by the Flippa team.

## `earlyAccessOnly` (type: `boolean`):

Only First-Access listings.

## `revenueGenerating` (type: `string`):

Filter by whether the listing is currently revenue generating.

## `urls` (type: `array`):

Paste any flippa.com URLs to scrape directly. Supports search-results URLs (https://flippa.com/search?...) and listing URLs (https://flippa.com/12345 or https://flippa.com/12345-some-slug). Multi-URL is supported. Filter-mode fields are ignored. Pagination starts at the page in each URL and walks forward.

## `fetchDetails` (type: `boolean`):

When ON, also fetches the per-listing /v3/listings/{id} record. Adds external\_url, hostname, business\_model, industry, revenue\_per\_month, profit\_per\_month, app\_downloads\_per\_month, revenue\_sources, and seller\_location. Costs one extra HTTP call per listing.

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

Hard cap on listings pushed to the dataset. This is the actor's sole finite default limit. 0 means unlimited (bounded only by Max Pages and Flippa's own ~10,000-listing / 400-page ceiling).

## `maxPages` (type: `integer`):

Maximum pages to walk per search URL. Leave at 0 to walk the whole result set for that search: the run still stops at Flippa's own real ~10,000-listing / 400-page ceiling, at the result total the server reports for a narrower search, or on an empty/all-duplicate page — never an artificial cap. Set a positive number to limit pages explicitly.

## `resumeFromRunId` (type: `string`):

Optional. ID of a previous run of this actor (or a dataset ID). Listings already in that dataset are skipped, so this run returns only NEW listings (a delta). Combine both runs' datasets for the full set. Cannot be combined with Incremental mode unless this is the very first incremental run for the chosen state key (see below) — otherwise turn Incremental mode on for later scheduled runs instead.

## `incrementalMode` (type: `boolean`):

For scheduled/repeated runs of the SAME search or URLs. The actor remembers what it saw last time and marks each listing NEW, UPDATED, UNCHANGED, REAPPEARED, or EXPIRED. Unlike Resume above (which continues one specific interrupted run from a pasted id), this remembers state itself between runs — no id to paste. Off by default so a normal run's output is unchanged.

## `stateKey` (type: `string`):

Optional name for this monitoring campaign, used with Incremental mode above. Leave empty to key the saved state automatically off the search filters (or URLs) and Fetch Detail Data setting, so two different searches never share a baseline. Set an explicit name to track the same campaign even if you later tweak filters, or to run several separate campaigns against the same filters.

## `emitUnchanged` (type: `boolean`):

When Incremental mode is on, UNCHANGED listings are normally skipped so you only see what's new or different. Turn this on to also return them, tagged changeType: UNCHANGED. These rows are returned AND billed like any other row. Off by default.

## `emitExpired` (type: `boolean`):

When Incremental mode is on and this run scans the full tracked search to its natural end, listings previously seen but no longer found are returned as tombstone rows tagged changeType: EXPIRED. These rows are returned AND billed like any other row. Skipped whenever this run does not prove a complete scan (e.g. Resume is set, Max Listings capped the run, or pagination stopped early) — the previous state for those listings is kept as-is. Off by default.

## `proxy` (type: `object`):

Default Apify proxy works fine for flippa.com. Residential is optional and rarely needed.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON — the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "status": [
    "open"
  ],
  "propertyTypes": [
    "ai_apps_and_tools"
  ],
  "sortBy": "most_relevant",
  "verifiedRevenueOnly": false,
  "verifiedTrafficOnly": false,
  "manuallyVettedOnly": false,
  "editorsChoiceOnly": false,
  "superSellerOnly": false,
  "brokerSellerOnly": false,
  "sponsoredOnly": false,
  "buyItNowOnly": false,
  "reserveMetOnly": false,
  "priceDroppedOnly": false,
  "managedByFlippaOnly": false,
  "earlyAccessOnly": false,
  "revenueGenerating": "any",
  "urls": [
    "https://flippa.com/search?search_template=most_relevant&filter%5Bstatus%5D=open&filter%5Bproperty_type%5D=ai_apps_and_tools"
  ],
  "fetchDetails": true,
  "maxListings": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  },
  "maxNotifyListings": 50
}
```

# 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 = {
    "mode": "search",
    "status": [
        "open"
    ],
    "propertyTypes": [
        "ai_apps_and_tools"
    ],
    "urls": [
        "https://flippa.com/search?search_template=most_relevant&filter%5Bstatus%5D=open&filter%5Bproperty_type%5D=ai_apps_and_tools"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/flippa-com-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 = {
    "mode": "search",
    "status": ["open"],
    "propertyTypes": ["ai_apps_and_tools"],
    "urls": ["https://flippa.com/search?search_template=most_relevant&filter%5Bstatus%5D=open&filter%5Bproperty_type%5D=ai_apps_and_tools"],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/flippa-com-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 '{
  "mode": "search",
  "status": [
    "open"
  ],
  "propertyTypes": [
    "ai_apps_and_tools"
  ],
  "urls": [
    "https://flippa.com/search?search_template=most_relevant&filter%5Bstatus%5D=open&filter%5Bproperty_type%5D=ai_apps_and_tools"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/flippa-com-scraper --silent --output-dataset

```

## MCP server setup

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