# Flippa Scraper - Businesses, Revenue, Profit & Multiples (`abotapi/flippa-com-scraper`) Actor

From $0.80/1K. Scrape Flippa listings with full enrichment, including revenue, profit, valuation multiples, traffic, business age, location, monetization, badges and more. Search with filters or URLs, with concurrent enrichment for 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
- **Features:** Limited permissions
- **Stats:** 3 total users, 0 monthly users, 100.0% 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?

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: Asking Price, Financials, Multiples and Verification Data

Flippa Scraper turns flippa.com, a marketplace for buying and selling websites, apps, domains and online businesses, into structured, exportable data. Search live and recently sold listings by 25+ filters, or paste search-result and single-listing links straight from your browser. Each record carries 80+ curated fields (asking price, monthly and annual profit/revenue, profit and revenue multiples, traffic, site age, seller location, monetization, sale method, plus every verification and badge flag the listing shows) alongside the complete raw payload the marketplace returned. Export to JSON, CSV or Excel, or read the dataset through the API. Turn on Incremental mode to monitor a saved search on a schedule and receive only what changed.

### Why This Scraper?

- **80+ curated fields, plus the full payload.** Asking price, monthly/annual profit and revenue, profit and revenue multiples, traffic (uniques, page views), site age, seller location, monetization and sale method, with the complete search-card and detail payloads preserved under `raw` and `apiRaw` so nothing the marketplace shows is left behind.
- **Two ways to find listings.** Filter by 25+ dimensions, from asset type and sale method to price/profit/revenue ranges, verified status, seller location and domain extension, or paste any flippa.com search-result or listing URL straight from your browser.
- **Auctions and classifieds together.** Track Buy It Now, reserve-met, price-dropped and First Access auctions alongside fixed Asking Price listings, open or recently sold.
- **Trust signals on every search record.** Verified revenue, verified traffic, manual vetting, Super Seller, Editor's Choice, broker and sponsored tags come through without extra clicks.
- **Resilient to interruption.** An aborted run keeps every record already collected, and an automatic same-run checkpoint survives a platform restart or migration without duplicate rows or double charges.
- **Built for monitoring.** Incremental mode returns only new, updated and reappeared listings on a recurring run, and expired ones once a run proves it covered the whole tracked search, or resume one specific interrupted crawl with a run id.
- **Billed only for what actually comes back.** The optional per-listing detail fetch is charged only when it is retrieved and kept in the output, never for a call that failed or a row suppressed as unchanged.

### Use Cases

- **Buyers and brokers:** screen new listings against your own thresholds (multiples, verified revenue, minimum traffic) as soon as they list.
- **Market and pricing research:** build a historical dataset of asking prices, multiples and time-on-market across asset types to spot trends.
- **Deal-flow monitoring:** track a saved search on a schedule and get only what changed, so a pipeline stays current without re-reading the whole marketplace.
- **Due diligence:** pull the detail record for a shortlist of listing URLs into your own workflow or spreadsheet before making an offer.

### Data You Get

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

| Field | Example |
|---|---|
| `id` / `url` | `"10000001"` / `"https://flippa.com/10000001-sample-listing"` |
| `title` / `propertyName` | `"Established SaaS tool with recurring subscribers"` / `"sample-saas-app.test"` |
| `hostname` | `null` (detail-only field, currently dead in every mode, see below) |
| `propertyType` / `monetization` | `"saas"` / `"Subscription"` |
| `category` / `siteType` | `"Internet"` / `"AiAppsAndTools"` |
| `saleMethod` / `saleMethodTitle` / `priceDetails` | `"classified"` / `"Asking Price"` / `"Asking Price"` (`priceDetails` mirrors `saleMethodTitle`; `saleMethod` is `"auction"` on cards tagged Auction) |
| `status` | `"open"` (also `"won"` for recently sold) |
| `price` / `priceText` | `42000` / `"USD $42,000"` |
| `priceDropped` / `priceDroppedPercent` | `true` / `15` |
| `monthlyProfit` / `monthlyRevenue` / `profitMultiple` / `revenueMultiple` | `2100` / `3400` / `3.1` / `1.9` |
| `uniquesPerMonth` / `pageViewsPerMonth` | `12400` / `45000` |
| `siteAge` / `ageInMonths` | `"4 years"` / `4` (search mode reads the site's own years figure straight through without converting to months, so this is not actually a months count there; a pasted single-listing URL does convert it, see below) |
| `businessLocation` / `sellerLocation` | `"ON, Canada"` / `null` (detail-only field, currently dead in every mode) |
| `isVerifiedRevenue` / `isVerifiedTraffic` | `true` / `false` |
| `isManuallyVetted` / `isSuperSeller` | `false` / `true` |
| `bidCount` / `timeLeft` | `3` / `"8 days left"` (read from the "N bids · N days left" text on auction cards and from the "N bids" and "N days left" lines of a pasted single-listing page; `null` when the card shows none. `timeLeft` is the site's relative countdown, not an end timestamp; it changes every day, so incremental mode never counts it as a change) |
| `isBrokerSeller` / `status` | `true` / `"open"` (`isBrokerSeller` is read from the card byline: `true` for "Brokered by ..." and for "Listed by Partner Broker", `false` for "Marketplace · Listed by Owner", and `null` when the card carries no such byline or on a pasted single-listing URL; `status` is the `filter[status]` of the search URL when it names exactly one status, and `won` on an auction card marked Sold, otherwise `null`) |
| `viewsCount` / `watchersCount` / `commentsCount` | `263` / `10` / `3` (the "N Views", "N Watchers" and "N Comments" counters of a pasted single-listing page; `null` on search cards; they change with every visit so they never mark a listing as changed in incremental mode) |
| `description` | `"Sample listing text"` (single-listing pages only, from the page's own structured data) |
| `allVerifications` / `verifications` | `[]` / `[]` (search cards only show a Data Verified badge, exposed as `isVerifiedRevenue`; provider names are filled in only when the source serves them) |
| `countryName` / `formattedAgeInYears` | `"Germany"` / `"4 years"` (location and age text shown on the card) |
| `listingUrl` / `propertyTypeLabel` | `"https://flippa.com/10000001-sample-listing"` / `"SaaS"` (the card's View Listing link and type label) |
| `listedBy` / `brokerName` / `brokerAvatarUrl` | `"Marketplace · Listed by Owner"` / `"Sample Broker"` / `"https://static.flippa.com/avatars/sample.png"` (the seller byline; broker name and avatar are set only on brokered listings, `null` otherwise) |
| `integrations` | `["stripe"]` |
| `raw` / `apiRaw` | full search-card payload, preserved verbatim / listing detail payload (currently always `null`, see below) |

A search-mode record also carries `targetRaiseAmount`, `ttmRevenue`, `authorityScore`, `appRating`, `badges`, `keyData`, `scores`, early-access fields and several media/thumbnail variants, all pulled straight from the search card. Detail-only fields (`externalUrl`, `businessModel`, `industry`, `revenueSources`, `appDownloadsPerMonth`) currently come back `null`/empty in every mode because flippa.com's anonymous per-listing detail feed is not answering (observed since 2026-09); see "What a pasted single-listing URL returns" below for the fields that are also missing specifically on a pasted single-listing URL. Incremental mode adds four extra columns on top: `changeType` (`"NEW"`, `"UPDATED"`, `"UNCHANGED"`, `"REAPPEARED"` or `"EXPIRED"`), `changedFields` (an array, populated only on `"UPDATED"` rows), `firstSeenAt` and `lastSeenAt`.

### How to Use

1. Pick a **mode**: `search` (filter by 25+ dimensions) or `url` (paste flippa.com search-result or listing links).
2. For Search mode, set your filters (asset type, price/profit/revenue range, verification, seller location and more). For URL mode, paste one or more links.
3. Turn **Fetch Detail Data** on or off, and set **Max Listings** / **Max Pages** to control run size and cost.
4. Click **Start**, then download the dataset as JSON, CSV or Excel, or read it through the API.

**Search by filters:**

```json
{
  "mode": "search",
  "status": ["open"],
  "propertyTypes": ["saas"],
  "sortBy": "most_recent",
  "fetchDetails": true,
  "maxListings": 25
}
```

**Verified-revenue listings above a profit floor:**

```json
{
  "mode": "search",
  "status": ["open"],
  "verifiedRevenueOnly": true,
  "minMonthlyProfit": 500,
  "fetchDetails": true,
  "maxListings": 25
}
```

**Supported URL shapes (URL mode).** Every row below was checked against the live site.

| URL shape | Example | Notes |
|---|---|---|
| Search results | `https://flippa.com/search?search_template=most_relevant&filter%5Bstatus%5D=open&filter%5Bproperty_type%5D=ai_apps_and_tools` | Any `filter[...]` parameter is kept as pasted. |
| Search, native page form | `https://flippa.com/search?filter%5Bstatus%5D=open&page=2&pagination=true` | `page=N&pagination=true` and `page[number]=N` both mean "start at page N". |
| Sold listings | `https://flippa.com/search?filter%5Bstatus%5D=won` | Recently sold. |
| Sorted search | `https://flippa.com/search?sort_alias=most_recent` | |
| Collection | `https://flippa.com/buy/saas` | `/buy/<collection>`. |
| Category | `https://flippa.com/buy/categories/internet` | `/buy/categories/<name>`. |
| Legacy site type | `https://flippa.com/buy/sitetype/saas` | Flippa redirects only some of these (for example to `/buy/saas`); an unknown name such as `ready-made` returns the unfiltered listing, so prefer `/buy/<name>` or filter parameters. |
| Landing page | `https://flippa.com/websites` | |
| Localized search | `https://flippa.com/es/search?filter%5Bproperty_type%5D=saas&filter%5Bstatus%5D=open` | Same results as the English path for the same filters. |
| Single listing | `https://flippa.com/13817253-android-app-builder...` | `/<id>` or `/<id>-slug`; `www.flippa.com` and `http://` are accepted. Returns the detail record described below. |

A page number in the URL is the start page and the walk continues forward. There is no seller or profile page shape. Any other URL is skipped with a warning in the log.

**Sorting in Search mode.** `sortBy` accepts `most_relevant`, `most_recent`, `ending_soonest`, `most_active`, `lowest_price`, `highest_price` and `most_profitable`.

**Default behaviour change (URL mode).** If URL mode runs with the `urls` field left untouched, it scrapes the 10 prefilled example URLs (a search, its native page 2, two single-listing pages, sold, a collection, a category, a landing page, a localized search and a sorted search), splitting Max Listings across them. With the default Max Listings of 20 each URL gets a share of 2 listings and each single-listing URL returns 1, so the 10 URLs return about 18 listings and every one of them is reached. The two single-listing URLs each return their record with the `detail-enrichment` event, so a default run is billed for that event twice instead of failing with "no URLs". Replace or clear the list to scrape only your own links.

**Paste multiple search 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_relevant&filter%5Bstatus%5D=open&filter%5Bproperty_type%5D=ecommerce_store"
  ],
  "fetchDetails": false,
  "maxListings": 40
}
```

**Recurring monitoring (schedule this run with Incremental mode on):**

```json
{
  "mode": "search",
  "status": ["open"],
  "propertyTypes": ["saas"],
  "incrementalMode": true,
  "maxListings": 100
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/flippa-com-scraper").call(run_input={
    "mode": "search",
    "propertyTypes": ["saas"],
    "status": ["open"],
    "maxListings": 25,
})
for listing in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(listing["title"], listing["price"], listing["monthlyProfit"])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/flippa-com-scraper').call({
  mode: 'search',
  propertyTypes: ['saas'],
  status: ['open'],
  maxListings: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### What a pasted single-listing URL returns

Pasting one listing's URL (`https://flippa.com/<id>`) in URL mode fetches just that record from the public listing page, since flippa.com's anonymous per-listing detail feed is not answering (observed since 2026-09; kept as an automatic fallback in case access returns). The listing page still supplies identity, asking price, monthly profit/revenue, profit and revenue multiples, page views, the `viewsCount`, `watchersCount` and `commentsCount` counters, and site age (converted to months here, unlike the search-mode value described above) and business location directly; it also builds its own small `raw` object from the page rather than leaving it null. It also supplies `description`, `bidCount`, `timeLeft` and `reserveMet` for auctions. It does not carry the much longer list of fields that only ever came from a search-results card: `status`, every verification and badge flag (`isVerifiedRevenue`, `isVerifiedTraffic`, `isManuallyVetted`, `isEditorsChoice`, `isSuperSeller`, `isSponsored`, `isBrokerSeller`, and the other early-access/`is*` flags), `uniquesPerMonth`, `integrations`, `allVerifications`, `badges`, `scores`, `ttmRevenue`, `targetRaiseAmount`, `authorityScore`, `appRating`, `summary`, `monetization`, `primaryPlatform`, `endAt`, `keyData`, and the full search-card `apiRaw`/`raw` payload; these come back `null`, empty, or absent on a pasted single-listing URL. `category`/`propertyType` on a pasted URL come from the listing page's own structured data rather than the search index, so the exact wording can differ slightly from a search-mode record for the same listing. If a listing you need is reachable through a filtered search instead of a direct link, searching for it returns the fuller record.

#### Pagination and Max Pages

`maxPages: 0` (the default) does not mean "no results". It means the walk continues, page by page, until one of the run's real terminators is hit: the result total flippa.com's own search response reports for that search, flippa.com's own ceiling of 25 listings per page across 400 pages (about 10,000 results per search), or an empty page. A page whose listings were already collected earlier in the same run does not stop the walk either; it is skipped and pagination continues, so overlapping searches never cut a later search short. **Max Listings** (default `20`) is the actor's sole finite soft cap on how many records a run pushes; set it to `0` to pull the whole result set for a search, still bounded by the terminators above, or set **Max Pages** to a positive number to cap pages explicitly instead.

#### Resume and recurring updates

There are two different tools here; pick the one that matches what you are doing.

| Need | Use |
|---|---|
| A crawl stopped and should continue | `resumeFromRunId` |
| Run the same search on a schedule and receive only changes | `incrementalMode` |
| Keep separate recurring campaigns for similar searches | distinct `stateKey` values |
| 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. Duplicate ids from earlier in the same run, or from a previous run supplied through `resumeFromRunId`, are skipped without stopping the walk, so a resumed run keeps paging past everything it already has and still reaches genuinely new listings further into the result set. An automatic same-run checkpoint also protects against a platform migration or restart without any input needed: an interrupted run picks up from where it stopped, 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 no run id needs to be pasted. The first run returns everything as `NEW`. Later runs return only `NEW`, `UPDATED` and `REAPPEARED` listings by default; unchanged listings are suppressed and not billed unless `emitUnchanged` is on. `EXPIRED` rows, and any later `REAPPEARED` classification, are only produced once a run both has `emitExpired` on and proves it scanned the whole tracked search to its natural end (not capped by Max Listings, not a resume, not resuming from a mid-walk checkpoint); a partial run leaves the previous state untouched instead of guessing. When you paste more than one search or listing URL in a single run, listing ids are deduplicated across all of them so the same listing is never pushed twice, but this dedup only ever skips pushing a duplicate, never stops an individual search's own pagination early, so a later search in a multi-URL run is not cut short by overlap with an earlier one.

`EXPIRED` means a previously tracked listing was not found anywhere in this run's scan; it does not distinguish a listing that sold from one that was simply delisted or removed. If your tracked search only matches open listings (`status: ["open"]`), a sale that moves a listing to "won" status looks identical to a straightforward removal: both surface as `EXPIRED`. Include `"won"` in `status` if you want a sold listing to keep being tracked (as an `UPDATED` row) instead of disappearing into `EXPIRED`. **What counts as UPDATED.** Every output field is compared against the saved copy, field by field; `changedFields` names the ones that moved. Left out on purpose, because they change with the viewer or the clock and not with the listing: `listingWatchable`, `earlyAccessDaysRemaining`, `earlyAccessPercentage`, and the matching watch and early-access viewer counters inside `raw` and `apiRaw`. Price, bid count, end time and status do count. Add more names with `ignoreFieldsForChanges`, a list of top-level output field names (for example `bidCount`, `endAt`) that are left out of the comparison; changing the list keeps your saved state. A pasted URL that starts on a page after the first (`page[number]` above 1) never produces `EXPIRED` rows, because the earlier pages were not scanned. State is isolated per search filter and per `fetchDetails` setting automatically; set `stateKey` to name or deliberately share a monitoring campaign.

### 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.

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` to filter by dimensions, or `url` to paste flippa.com links. |
| `status` | array | (none, behaves as `open` when left empty) | `open` for live listings, `won` for recently sold, or both. |
| `propertyTypes` | array | (none) | Asset types: 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. Leave empty for all. |
| `siteTypes` | array | (none) | Granular site type within an asset type. Leave empty for any. |
| `saleMethods` | array | (none) | `auction`, `classified`, or both. Leave empty for both. |
| `sortBy` | string | `most_relevant` | `most_relevant`, `most_recent`, `ending_soonest`, `most_active`, `lowest_price`, `highest_price`, or `most_profitable`. |
| `minPrice` | integer | (none) | Minimum asking price in USD. |
| `maxPrice` | integer | (none) | Maximum asking price in USD. |
| `minMonthlyProfit` | integer | (none) | Minimum monthly net profit. |
| `maxMonthlyProfit` | integer | (none) | Maximum monthly net profit. |
| `minMonthlyRevenue` | integer | (none) | Minimum monthly revenue. |
| `maxMonthlyRevenue` | integer | (none) | Maximum monthly revenue. |
| `minUniquesPerMonth` | integer | (none) | Minimum monthly unique visitors. |
| `maxUniquesPerMonth` | integer | (none) | Maximum monthly unique visitors. |
| `minAgeMonths` | integer | (none) | Minimum listing/site age in months. |
| `maxAgeMonths` | integer | (none) | Maximum listing/site age in months. |
| `tlds` | array | (none) | Domain extensions to include (com, org, io, ai, app, and so on). Leave empty for any. |
| `sellerLocation` | string | (none) | ISO 2-letter country code (us, gb, au) or region code (afr, nam, sam, asi, eeu, weu, oce). |
| `verifiedRevenueOnly` | boolean | `false` | Only listings with Flippa-verified revenue. |
| `verifiedTrafficOnly` | boolean | `false` | Only listings with Flippa-verified traffic. |
| `manuallyVettedOnly` | boolean | `false` | Only listings the marketplace team or a broker has manually vetted. |
| `editorsChoiceOnly` | boolean | `false` | Editor's Choice listings only. |
| `superSellerOnly` | boolean | `false` | Listings from Super Sellers only. |
| `brokerSellerOnly` | boolean | `false` | Brokered listings only. |
| `sponsoredOnly` | boolean | `false` | Sponsored (premium) listings only. |
| `buyItNowOnly` | boolean | `false` | Auctions with a Buy It Now option only. |
| `reserveMetOnly` | boolean | `false` | Auctions where the reserve has been met only. |
| `priceDroppedOnly` | boolean | `false` | Listings whose price has been reduced only. |
| `managedByFlippaOnly` | boolean | `false` | Listings managed by the marketplace team only. |
| `earlyAccessOnly` | boolean | `false` | First Access listings only. |
| `revenueGenerating` | string | `any` | `yes`, `no`, or `any`. |
| `urls` | array | 10 example URLs, one per working shape | flippa.com URLs to scrape directly (URL mode): search results (filtered, sorted, sold/won, localized `/es/search`), `/buy/<collection>`, `/buy/categories/<name>`, `/websites` and listing pages (`/<id>` or `/<id>-slug`, www or http accepted). Filter-mode fields are ignored. |
| `fetchDetails` | boolean | `true` | When on, also fetches the per-listing detail record, meant to add `externalUrl`, `hostname`, `businessModel`, `industry`, `revenuePerMonth`/`profitPerMonth`, `appDownloadsPerMonth`, `revenueSources` and `sellerLocation`. Currently none of these come back populated, since flippa.com's anonymous per-listing detail feed is not answering; see the FAQ below. Costs one extra request per listing while the feed is being tried; ignored for a pasted single-listing URL, which is always treated and billed as a detail record regardless of this setting. |
| `maxListings` | integer | `20` | Hard cap on listings pushed to the dataset, the actor's sole finite default limit. `0` means unlimited, bounded only by Max Pages and flippa.com's own ceiling. |
| `maxPages` | integer | `0` | Pages to walk per search (25 listings/page). `0` walks the whole result set for that search, still bounded by flippa.com's own result total or page ceiling. A positive number caps pages explicitly. |
| `resumeFromRunId` | string | (none) | ID of a previous run or dataset. Listings already collected there are skipped, so this run returns only new ones. |
| `incrementalMode` | boolean | `false` | For scheduled runs of the same search or URLs: remembers state itself and classifies each listing NEW, UPDATED, UNCHANGED, REAPPEARED or EXPIRED. |
| `stateKey` | string | (none) | Optional name for a monitoring campaign. Left empty, the state key is derived automatically from the search filters (or URLs) and the Fetch Detail Data setting. |
| `emitUnchanged` | boolean | `false` | Incremental mode only. Also return (and bill) listings unchanged since the last run. |
| `emitExpired` | boolean | `false` | Incremental mode only. Also return (and bill) listings from a previous run no longer found, once a run has fully scanned the tracked search. |
| `ignoreFieldsForChanges` | array | `[]` | Incremental mode only. Top-level output field names to leave out when deciding whether a listing is `UPDATED` (for example `bidCount` or `status` if only price changes matter; `timeLeft` and the viewer-specific flags are always left out). Changing this list keeps your saved state. |
| `proxy` | object | (none, prefilled with Apify Proxy enabled) | The Apify datacenter proxy works for flippa.com; residential is not required. |
| `mcpConnectors` | array | (none) | Optional: send a summary of each record to apps authorized under Integrations. |
| `notionParentPageUrl` | string | (none) | Notion connector only: page under which item pages are created. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run. Does not affect the dataset. |

### Output Example

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

```json
{
  "id": "10000001",
  "url": "https://flippa.com/10000001-sample-listing",
  "title": "Established SaaS tool with recurring subscribers",
  "summary": "Brief seller pitch text shown on the search card.",
  "propertyName": "sample-saas-app.test",
  "propertyType": "saas",
  "siteType": "AiAppsAndTools",
  "category": "Internet",
  "monetization": "Subscription",
  "primaryPlatform": null,
  "saleMethod": "classified",
  "saleMethodTitle": "Asking Price",
  "status": "open",
  "endAt": null,
  "price": 42000,
  "originalPrice": 48000,
  "priceText": "USD $42,000",
  "priceDropped": true,
  "priceDroppedPercent": 12.5,
  "currency": "USD",
  "monthlyProfit": 2100,
  "monthlyRevenue": 3400,
  "annualProfit": 25200,
  "annualRevenue": 40800,
  "profitMultiple": 3.1,
  "revenueMultiple": 1.9,
  "uniquesPerMonth": 12400,
  "pageViewsPerMonth": 45000,
  "authorityScore": 28,
  "siteAge": "4 years",
  "ageInYears": "4 years",
  "ageInMonths": 4,
  "businessLocation": "ON, Canada",
  "isVerifiedRevenue": true,
  "isVerifiedTraffic": false,
  "isManuallyVetted": false,
  "isEditorsChoice": false,
  "isSuperSeller": true,
  "isBrokerSeller": false,
  "isSponsored": false,
  "bidCount": null,
  "timeLeft": null,
  "thumbnailUrl": "https://static.flippa.com/assets/sample-placeholder.svg",
  "keyData": [
    { "label": "Type", "value": "SaaS" },
    { "label": "Site Age", "value": "4 years" }
  ],
  "badges": [],
  "allVerifications": [],
  "verifications": [],
  "countryName": "Canada",
  "formattedAgeInYears": "4 years",
  "listingUrl": "https://flippa.com/10000001-sample-listing",
  "propertyTypeLabel": "SaaS",
  "listedBy": "Marketplace · Listed by Owner",
  "brokerName": null,
  "brokerAvatarUrl": null,
  "priceDetails": "Asking Price",
  "integrations": ["stripe"],
  "raw": { "/* full search-card object */": "..." }
}
```

#### Output views and run summary

The dataset has four Output-tab views over the same listing rows: `overview` (card essentials), `financials` (price, profit, revenue, multiples, traffic), `detail` (enrichment and listing-page fields such as website, industry, business model, revenue sources, auction dates) and `changes` (incremental change type, changed fields, first and last seen). When a run covers several searches or URLs, a summary of items per search is stored in the key-value store record `OUTPUT`.

### Plan Requirement

- **Proxy.** A datacenter Apify proxy is enough for flippa.com: measured, the search pages answer 200 with full listing HTML and no challenge page, so no residential proxy is needed. The run uses the Apify datacenter connection first and a backup datacenter connection if that one is refused. If this run cannot use the Apify datacenter proxy (for example on a free plan), it continues on the backup connection, shows the first notice below, and fails only when neither connection can load pages. A proxy you enter yourself gets no backup connection.
- **What you see in the log and status when the connection is a problem.**
  - Notice when the selected connection is refused and the run moves to the backup: "The selected connection is unavailable to this run. Apify free plans do not include residential proxies. Continuing on a backup connection; some pages may still be unavailable. For residential access, upgrade at https://apify.com/pricing or supply your own proxy URLs."
  - Notice when pages were served by the backup: "Served over the backup connection (the default connection was unavailable)."
  - Failure when the proxy is refused for the account: "The proxy connection was refused for this account, so no page could be read. Your Apify plan does not include proxy access; a paid plan is required: https://apify.com/pricing. If you entered your own proxy URLs, check that their credentials are valid."
  - Failure when the backup also cannot load the pages: "No results: residential proxies are unavailable on this run (Apify free plans do not include them), and the backup connection could not load the requested Flippa pages. Upgrade at https://apify.com/pricing or supply your own proxy URLs, then try again."
  - Failure when no results page loads at all: "Could not load any results page (the requests failed), so nothing was collected. This is a connection problem, not an empty search. Please try again later."
- **Billing.** Three events apply: `apify-actor-start` once per run, `apify-default-dataset-item` once per listing row pushed to the dataset, and `detail-enrichment` once per listing whose detail data was retrieved and kept (per listing, not per page). Nothing is charged for rows that are suppressed as unchanged, skipped as duplicates, or that failed. A pasted single-listing URL always carries `detail-enrichment`, since fetching that listing's data is what returns the record. Current rates are on the **Pricing** tab.
- Detail enrichment (`fetchDetails`, on by default) makes one extra request per listing in Search mode while the detail feed is still being tried. Once the feed's repeated failures trip an internal breaker, no further detail requests are made for the rest of that run even with the toggle on.
- flippa.com's anonymous per-listing detail feed is not currently answering (observed since 2026-09), so `externalUrl`, `hostname`, `businessModel`, `industry`, `revenueSources` and `appDownloadsPerMonth` come back empty across every mode until it is restored. Fields from a search-results card are unaffected in search mode; a pasted single-listing URL lacks a longer list for a different reason, see "What a pasted single-listing URL returns" above.

### FAQ

#### How much does it cost?

You pay per listing returned, with the optional detail-enrichment surcharge billed only when it is actually retrieved. The **Pricing** tab shows the current rates. Use **Max Listings** to cap the cost of any run.

#### Is it legal to scrape flippa.com?

This actor collects only publicly available marketplace listing data. You are responsible for how you use it: follow flippa.com's terms and the laws that apply to you, and get legal advice if you plan commercial redistribution, particularly around any seller-identifying or financial details a listing discloses.

#### Can I monitor a search over time and only get new or changed listings?

Yes. Schedule the actor from the **Schedules** tab and turn on **Incremental mode**. Each run then returns only new, updated and reappeared listings, and unchanged ones are not billed. Turn on `emitExpired` if you also want listings that disappeared from the tracked search returned as tombstone rows, once a run proves it scanned the whole search.

#### Why are some fields null on a listing I scraped?

Two separate reasons. First, flippa.com's anonymous per-listing detail feed is not currently answering, so a handful of detail-only fields (`externalUrl`, `hostname`, `businessModel`, `industry`, `revenueSources`, `appDownloadsPerMonth`) come back empty everywhere until that changes. Second, if you pasted one listing's URL directly rather than finding it through a search, several search-card-only fields (`status`, verification and badge flags, `bidCount`, `uniquesPerMonth`) are not available on that page and also come back null; see "What a pasted single-listing URL returns" above.

#### Why did my run fail instead of returning an empty dataset?

If flippa.com refuses every request, the run stops with a clear message so "no listings matched" is never confused with "nothing could be read", and nothing is charged. A connection problem is reported with its own message, and an account without proxy access is pointed to https://apify.com/pricing. If the site was reachable but your filters matched nothing, the run finishes successfully with an empty dataset and a status message instead.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 Want more e-commerce data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>📇 <a href="https://apify.com/abotapi/businessesforsale-com-scraper"><b>BusinessesForSale.com Scraper</b></a><br>Extract businesses and franchises listed for sale on BusinessesForSale.com. Search by...</td><td>🛒 <a href="https://apify.com/abotapi/product-reviews-australia-scraper"><b>ProductReview.com.au Scraper</b></a><br>Scrape ProductReview.com.au products, businesses and customer reviews. Search by...</td></tr>
<tr><td>📇 <a href="https://apify.com/abotapi/bizbuysell-scraper"><b>BizBuySell Scraper</b></a><br>Extract business-for-sale and franchise listings from bizbuysell.com with financials...</td><td>📇 <a href="https://apify.com/abotapi/bizquest-scraper"><b>BizQuest Scraper</b></a><br>Extract business-for-sale, franchise, and asset listings from BizQuest. Search by...</td></tr>
<tr><td>🏷️ <a href="https://apify.com/abotapi/2dehands-2ememain-scraper"><b>2dehands &amp; 2ememain</b></a><br>Scrape classifieds from 2dehands.be and 2ememain.be by keyword, filters, or URLs. Returns...</td><td>💼 <a href="https://apify.com/abotapi/superprof-tutor-scraper"><b>Superprof Scraper</b></a><br>Scrape Superprof tutors by subject and location, or paste tutor URLs. One rich record per...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/flippa-com-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# 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.

## `maxUniquesPerMonth` (type: `integer`):

Maximum monthly unique visitors. Leave empty for no maximum.

## `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: search results (filtered, sorted, sold/won and localized /es/search), category and collection pages (/buy/saas, /buy/categories/<name>), property-type landing pages (/websites) and listing pages (https://flippa.com/12345 or https://flippa.com/12345-some-slug, www or http hosts accepted). Every filter\[...] and sort parameter in the URL is kept. Flippa ignores a free-text query= parameter on its search page and returns the unfiltered listing for it, and it only redirects some legacy /buy/sitetype/<name> links (for example /buy/sitetype/saas); for any other /buy/sitetype/<name> it also returns the unfiltered listing, so use /buy/<name> or filter parameters instead. Pagination starts at the page in the URL (page\[number]=N or the site's own page=N\&pagination=true) and walks forward. Unsupported URLs are logged with a warning and skipped.

## `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.

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

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

## `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. A listing counts as UPDATED when any output field changed (price, bid count, end time, status, financials, badges and so on), compared field by field against the saved copy. Excluded from the comparison, because they change with the viewer or the clock rather than the listing: the watching/watched and early-access viewer flags and the early-access days-remaining and percentage counters (also inside the raw and apiRaw copies), plus anything you list in Ignore fields below. 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.

## `ignoreFieldsForChanges` (type: `array`):

Optional. Top-level output field names to leave out when deciding whether a listing is UPDATED, in addition to the built-in handling (viewer watch and early-access flags and counters never trigger UPDATED). Use this if a field in your setup turns out to be noisy, for example bidCount or endAt if you only care about price changes. Changing this list does not reset your saved state.

## `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",
    "https://flippa.com/search?filter%5Bproperty_type%5D=ai_apps_and_tools&filter%5Bstatus%5D=open&page=2&pagination=true&search_template=most_relevant",
    "https://flippa.com/13817253-android-app-builder-on-google-play-60k-installs-4-6-1k-mo-revenue-on-15-mo-costs-turns-websites-html-ai-prompts-into-apk-aab-apps-full-source",
    "https://flippa.com/13525113",
    "https://flippa.com/search?filter%5Bstatus%5D=won",
    "https://flippa.com/buy/saas",
    "https://flippa.com/buy/categories/internet",
    "https://flippa.com/websites",
    "https://flippa.com/es/search?filter%5Bproperty_type%5D=saas&filter%5Bstatus%5D=open",
    "https://flippa.com/search?search_template=most_relevant&sort_alias=most_recent&filter%5Bstatus%5D=open"
  ],
  "fetchDetails": true,
  "maxListings": 20,
  "maxPages": 0,
  "proxy": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": [],
  "maxNotifyListings": 50
}
```

# Actor output Schema

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

No description

## `financials` (type: `string`):

No description

## `detail` (type: `string`):

No description

## `changes` (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",
        "https://flippa.com/search?filter%5Bproperty_type%5D=ai_apps_and_tools&filter%5Bstatus%5D=open&page=2&pagination=true&search_template=most_relevant",
        "https://flippa.com/13817253-android-app-builder-on-google-play-60k-installs-4-6-1k-mo-revenue-on-15-mo-costs-turns-websites-html-ai-prompts-into-apk-aab-apps-full-source",
        "https://flippa.com/13525113",
        "https://flippa.com/search?filter%5Bstatus%5D=won",
        "https://flippa.com/buy/saas",
        "https://flippa.com/buy/categories/internet",
        "https://flippa.com/websites",
        "https://flippa.com/es/search?filter%5Bproperty_type%5D=saas&filter%5Bstatus%5D=open",
        "https://flippa.com/search?search_template=most_relevant&sort_alias=most_recent&filter%5Bstatus%5D=open"
    ],
    "proxy": {
        "useApifyProxy": true
    },
    "ignoreFieldsForChanges": []
};

// 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",
        "https://flippa.com/search?filter%5Bproperty_type%5D=ai_apps_and_tools&filter%5Bstatus%5D=open&page=2&pagination=true&search_template=most_relevant",
        "https://flippa.com/13817253-android-app-builder-on-google-play-60k-installs-4-6-1k-mo-revenue-on-15-mo-costs-turns-websites-html-ai-prompts-into-apk-aab-apps-full-source",
        "https://flippa.com/13525113",
        "https://flippa.com/search?filter%5Bstatus%5D=won",
        "https://flippa.com/buy/saas",
        "https://flippa.com/buy/categories/internet",
        "https://flippa.com/websites",
        "https://flippa.com/es/search?filter%5Bproperty_type%5D=saas&filter%5Bstatus%5D=open",
        "https://flippa.com/search?search_template=most_relevant&sort_alias=most_recent&filter%5Bstatus%5D=open",
    ],
    "proxy": { "useApifyProxy": True },
    "ignoreFieldsForChanges": [],
}

# 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",
    "https://flippa.com/search?filter%5Bproperty_type%5D=ai_apps_and_tools&filter%5Bstatus%5D=open&page=2&pagination=true&search_template=most_relevant",
    "https://flippa.com/13817253-android-app-builder-on-google-play-60k-installs-4-6-1k-mo-revenue-on-15-mo-costs-turns-websites-html-ai-prompts-into-apk-aab-apps-full-source",
    "https://flippa.com/13525113",
    "https://flippa.com/search?filter%5Bstatus%5D=won",
    "https://flippa.com/buy/saas",
    "https://flippa.com/buy/categories/internet",
    "https://flippa.com/websites",
    "https://flippa.com/es/search?filter%5Bproperty_type%5D=saas&filter%5Bstatus%5D=open",
    "https://flippa.com/search?search_template=most_relevant&sort_alias=most_recent&filter%5Bstatus%5D=open"
  ],
  "proxy": {
    "useApifyProxy": true
  },
  "ignoreFieldsForChanges": []
}' |
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/mA65LuPkawexbV7Cr/openapi.json