Logo of «2Captcha»To home page
Captcha bypass tutorials

Was this helpful?

How to scrape Flippa

Gregory Fisher
Gregory Fisher

Technical engineer

Flippa is a marketplace for buying and selling online businesses: SaaS products, e-commerce stores, content sites, YouTube channels, apps and domains. Every listing card shows an asking price, monthly profit and revenue, Flippa's profit multiple, the business type, industry, age and country. If you want to know what a SaaS with $10K monthly profit sells for, or track how asking prices move over time, that's the data you need.

Flippa sits behind Cloudflare, but it serves its search pages to an ordinary request, and all 50 cards of a page arrive in the first HTML response. What needs care is the numbers on them. Profit and revenue are printed rounded, the multiple doesn't always match the numbers next to it, the French version of the site converts prices to euros, and a "3-page" run can quietly return one page if pagination isn't checked.

This guide uses the open-source Flippa scraper from the 2scraper project. It reads any flippa.com search URL with any filters, plus category pages such as /websites, /apps, /domains and /buy/sitetype/saas, and writes one row per listing to JSON or CSV. The figures below come from the project's README, changelog and troubleshooting notes, each with the date it was measured.

What you get

One row per listing, 33 columns. The useful ones:

Field What's in it
sku Flippa's numeric listing ID, the key for comparing runs
url The listing's link, flippa.com/<id>-<slug>
title The card heading: the business name, or something like "SaaS | Internet" for a confidential listing
description The seller's one-line summary
price, currency Asking price, or the starting price or current bid on an auction. Empty for "Open to Offers" listings and partial-equity sales
original_price, discount_pct Filled when the price was reduced. The discount is computed from the two prices, not copied from the "Reduced 28%" badge
asset_type, industry SaaS, Ecommerce, YouTube Channel… and Internet, Health and Beauty…
monthly_profit, monthly_revenue Per month, rounded to three significant figures. Profit can be negative
profit_multiple Flippa's own multiple as printed, e.g. 4.1
age_text, country As the site writes them: "12 years", "FL, United States"
bid_count Number of bids on an auction
broker_name, managed_by_flippa The broker on the card and whether it says "Brokered by Flippa"
page, position Where the row sat in the run; position restarts at 1 on every page

Some columns are in the schema but always empty now: monetization, revenue_multiple, status, sale_method, sponsored, editors_choice, confidential, verified_listing and image_url. Flippa rebuilt its search page on September 28–29, 2026, and the new cards don't show them. They stay so your downstream code doesn't break. There's also no brand, rating or in_stock column, since a marketplace for businesses has none of those.

What you need

  • Python 3.9 or newer.
  • Playwright with Chromium, the recommended engine. Selenium and pyppeteer versions are there too, plus a client for the Scraper API that needs no browser.
  • One virtual environment per engine. Playwright and pyppeteer pin incompatible pyee versions, and pyppeteer and Selenium clash on urllib3.
  • Nothing paid. Every number in the project was measured with no API key, no proxy and no hosted browser.

Installation

bash Copy
git clone https://github.com/2scraper/flippa-scraper.git
cd flippa-scraper
python3 -m venv .venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate

pip install -r requirements.txt
pip install -r requirements-playwright.txt
playwright install chromium

cp .env.example .env
python3 env_config.py   # shows which settings were loaded, without printing secrets

Leave .env empty for a plain run. If you add a key or proxy later, put it there rather than on the command line, where anything that can run ps can read it.

If you pick pyppeteer, know two things. It downloads a Chromium from 2018 that won't start on current macOS, so point PYPPETEER_EXECUTABLE_PATH at a modern browser. And it requires an old urllib3 with seven published advisories, including one that can forward proxy credentials across a redirect. If you run with proxy credentials, use Playwright.

First run

bash Copy
# SaaS listings, three pages, JSON and CSV
python3 playwright_scraper.py \
  --url "https://flippa.com/search?filter%5Bproperty_type%5D=saas" \
  --pages 3 --out saas_listings

# A category shortcut
python3 playwright_scraper.py --url "https://flippa.com/websites" --pages 2

On 2026-10-15 the first command, run from a datacenter server with no proxy and no key, returned 150 listings across 3 pages with exit code 0.

Defaults are --pages 1, --delay 2 (seconds between pages), --retries 3, --format both and --out flippa_listings. The easiest way to build a URL is to set the filters you want on flippa.com and copy the address bar. Every filter[...] parameter is kept as you pass it.

How the scraper works

Reading the cards

Flippa's search page is server-rendered: all 50 cards are in the first response, with no JavaScript needed. There's no structured listing data on it, no product JSON-LD and, since the rebuild, no embedded JSON either. So the cards themselves are the source.

A card is an li element with an ID like listing-12857417. The scraper matches "listing-" followed by digits, because the page also has filter counters with IDs like listing-category-count-saas. The price is read from the card's price column only, since the key-data grid above it also contains money ("USD $51.7K" monthly profit). The class names are Tailwind build output and change, so the scraper doesn't rely on them.

The site's own count in the filter panel ("Show 676 results") separates three situations: a query that matches nothing ("Show 0 results", exit 4), a page past the end of the listing (no cards but a count above zero, so the run is complete) and a page that wasn't a listing at all.

Pagination is checked, not assumed

Pages are ?page=N, the parameter Flippa's own next link uses, 50 listings each. On a 676-match filter measured on 2026-10-14, page 14 held the last 26 and page 15 returned HTTP 200 with no cards.

Every run checks this. Page 2 is fetched on its own and must contain listings page 1 didn't have. If it doesn't, the run stops as partial with stop_reason pagination_not_addressable. That check exists for a reason: an earlier version of the repository used a page parameter the site ignored, and every multi-page run returned one page of rows and reported success.

--concurrency N fetches pages 3 and beyond through N workers, each with its own browser and proxy, and only after the page 2 check has passed.

Engines

Engine Last live run
Playwright (recommended) 2026-10-15, after the rebuild: 150 listings, 3 pages, exit 0
pyppeteer 2026-09-19, before the rebuild: 50 listings, 2 pages
Selenium 2026-09-19, before the rebuild: 50 listings, 2 pages
Scraper API (scraper_api_client.py) 2026-09-19, before the rebuild: 50 listings, 2 pages, $0.0005 per page
Browser API (--cdp-endpoint) 2026-09-19, before the rebuild: 75 listings, 3 pages

On 2026-09-19 all three browser engines produced byte-identical rows for the same 50 listings. They share one parser, so the other engines should read the new page too, but only Playwright has been re-run since the rebuild.

Blocks, captcha and paid options

You don't need any paid product for Flippa. On 2026-09-19 and again on October 14–15 the site served its full search page to plain curl, to Playwright from a datacenter server and to GitHub's runners. A weekly canary run (Mondays) scrapes three real pages and checks the columns. Exit code 3 (blocked) isn't the normal state here, and when it happens a datacenter address is the most likely cause.

Here's what each of them adds.

Proxies

Proxies (--proxy, --proxy-file) give you volume from many addresses and a specific country. With --proxy-rotate per-page the browser is relaunched on each new IP, because carrying one session across addresses looks worse than either address alone. A two-page run through a 2Captcha residential proxy returned 50 listings with exit 0. Before starting a browser, the scraper sends one small request through the proxy. A rotated password then fails in a fraction of a second with exit 2 and a 407 in the message, instead of three 60-second timeouts per page. Lists can be generated with the Proxy API.

Scraper API

scraper_api_client.py needs no browser at all. On 2026-09-19 two pages cost $0.0005 each and every column matched the browser engines. The rebuilt page is server-rendered, so this path reads the same cards.

2Captcha Browser API

The Browser API (--cdp-endpoint) gives you a hosted browser with a chosen exit country and automatic captcha solving inside the browser. On 2026-09-19 it returned 75 listings across 3 pages, identical to a local run. --concurrency is refused there, since a profile allows one live connection. Copy the CDP URL from the dashboard: a URL assembled by hand from the documented format answered 401 deny_no_user. Selenium can't connect to an endpoint with credentials, so use Playwright or pyppeteer.

Fingerprints

Fingerprints (--fingerprint) are a separate subscription. A key with a healthy captcha balance got HTTP 403, so a run with --fingerprint on such a key stops with exit 5 before fetching anything. fingerprint_client.py --explain shows what could and couldn't be applied.

The only captcha is on the signup page

Listing pages have no challenge at all. The one Flippa does have is a Cloudflare Turnstile on /signup. The scraper detected its sitekey, 2Captcha returned a token in about five seconds, and the token was written into the page's response field. But a form's token is spent when the form is submitted, and this scraper never submits anything. So the default --solve-captcha when-blocked doesn't pay for a solve unless the listings are actually unreachable. The solver is there in case Flippa ever puts a challenge on the search pages. Task parameters are in the Cloudflare Turnstile docs.

Output files and exit codes

Each run writes the results and a .meta.json sidecar. Files are written atomically, and a run that finds nothing writes nothing unless you pass --allow-empty, so a failure can't replace yesterday's good data with an empty list. In the CSV, a title that looks like a formula is escaped so a spreadsheet won't run it.

Code Meaning
0 Listings written
1 Crash
2 Bad usage, including a proxy that fails its preflight check
3 Blocked before parsing
4 Zero listings, and the run can show the listing is empty
5 Zero listings because the content was never obtained: a timeout, a dead proxy, a page the parser couldn't read
6 Partial: some pages came back, then the run stopped

Two sidecar fields answer different questions, and mixing them up is how a short run gets read as the whole catalog:

Field What it tells you
status Did the run get the pages it asked for: complete, partial or failed
coverage Were those pages the whole listing: exhaustive, or window if there were more pages you didn't ask for

A --pages 3 run of a 27-page listing is complete and a window at the same time. The sidecar also lists failed and missing pages by number, the site's total_results at the first and last page, catalog_mutated if that number changed during the run, and duplicate listings across pages.

Locales convert prices

Flippa publishes three versions of search: /search, /fr/search and /es/search, and the localized ones do more than translate: they convert the prices. One listing on the same day, 2026-09-19:

URL Price Currency Age Industry
/search 436,829 USD 3 years Health and Beauty
/fr/search 380,546 EUR 3 années Santé et beauté

Both rows are correct for their page. The currency column follows the page instead of defaulting to dollars, and the parser knows the field labels in all three languages. Just don't mix two locales in one dataset.

Traps that look like bugs

  • profit_multiple doesn't equal price ÷ (12 × monthly_profit). It's Flippa's own figure as printed, and the card rounds the profit. Even with exact figures, 10 of 63 listings disagreed by more than 0.15 in a check on 2026-09-19. The scraper reports what the site publishes.
  • monthly_profit is negative. That's the listing, not the parser. Flippa prints a loss-making business's profit as "-USD $9".
  • Profit and revenue are round numbers. The card prints "USD $51.7K" or "USD $1.23M", and that's all the precision there is. Asking price and original price are printed in full and are exact.
  • price is empty on some rows. Those are "Open to Offers" listings, which show only a price guide range, or partial-equity sales. No price is invented.
  • A run wrote one page when you asked for three. Check stop_reason in the sidecar. pagination_not_addressable means the page 2 check failed. If you see it, Flippa has probably changed its pagination.
  • A captcha is reported on a page that has none. If you run through the Browser API, its extension adds an empty captcha-widgets element to every page. That's the extension's markup, not Flippa's. The scraper only counts it when it has content.

Comparing runs

Run the same search on two days and compare:

bash Copy
python3 playwright_scraper.py \
  --url "https://flippa.com/search?filter%5Bproperty_type%5D=saas" --pages 3 --out saas_mon

python3 playwright_scraper.py \
  --url "https://flippa.com/search?filter%5Bproperty_type%5D=saas" --pages 3 --out saas_tue

python3 diff_runs.py --old saas_mon.json --new saas_tue.json --fail-on-change

diff_runs.py joins the runs on sku and reports added, removed and changed listings. It tracks the asking price, the original price and discount, the currency and monthly profit, so a price cut shows up even when nothing else moved. It refuses to compare runs that aren't both complete. If the runs are windows, it still compares prices, but labels the added and removed listings as entered-window and left-window, because a listing that dropped off page 3 may simply have moved to page 4. Those don't trigger --fail-on-change.

A sample row

The first row of the repository's sample_output.json, from the 2026-10-15 run (the broker's name is redacted in the sample):

json Copy
{
  "source": "flippa.com",
  "scraped_at": "2026-10-15T06:44:06.615711+00:00",
  "url": "https://flippa.com/11816135-social-media-entertainment-business-founded-in-2014-...",
  "sku": "11816135",
  "title": "SaaS | Internet",
  "price": 2520000.0,
  "currency": "USD",
  "original_price": 3500000.0,
  "discount_pct": 28.0,
  "category": "saas",
  "price_source": "dom",
  "page": 1,
  "position": 1,
  "description": "Social media entertainment business founded in 2014, generating $2M in revenue with a 33% profit margin. Operates multiple websites in the online dating sector.",
  "asset_type": "SaaS",
  "industry": "Internet",
  "monthly_profit": 51700.0,
  "monthly_revenue": 160000.0,
  "profit_multiple": 4.1,
  "age_text": "12 years",
  "country": "Canada",
  "bid_count": null,
  "broker_name": "Broker name redacted for this sample",
  "managed_by_flippa": true
}

A confidential listing, so the title is just the type and industry. The price was cut from $3.5M to $2.52M, and 2,520,000 ÷ (12 × 51,700) gives about 4.06, which the card rounds to 4.1x.

Using the results: multiples by type and industry

A useful first report is the typical asking multiple by business type and industry, and the listings priced well below it.

python Copy
import json
from collections import defaultdict
from statistics import median

rows = json.load(open("saas_listings.json", encoding="utf-8"))

groups = defaultdict(list)
for r in rows:
    if r.get("profit_multiple") and (r.get("monthly_profit") or 0) > 0:
        groups[(r["asset_type"], r["industry"])].append(r)

for (atype, industry), items in sorted(groups.items(), key=lambda kv: -len(kv[1])):
    if len(items) < 5:
        continue
    m = median(r["profit_multiple"] for r in items)
    print(f"{atype} / {industry}: {len(items)} listings, median {m:.1f}x")
    for r in items:
        if r["profit_multiple"] < m * 0.6:
            print(f"   {r['profit_multiple']:.1f}x  {r['currency']} {r['price']:,.0f}  {r['url']}")

Keep in mind that this is an asking multiple, not a sale price, and that sold listings drop out of search. To see how prices move, collect runs over time with diff_runs.py rather than trusting one snapshot. Rows with negative profit are skipped because their multiple means nothing.

Limitations

  • Only search and category pages. Individual listing pages, sold listings and anything behind a login aren't read.
  • Profit and revenue have three significant figures, because that's what the card shows.
  • Nine columns are always empty since the September 2026 rebuild.
  • Only Playwright has been run live since the rebuild.
  • Fingerprints need a separate subscription.
  • Prices on /fr/ and /es/ are converted to euros, so keep locales apart.

Common questions

Do I need a proxy or an API key?
No. Every number in the project was measured without them. Proxies help when you run large volumes or need a specific country.

Does Flippa block scrapers?
Flippa is behind Cloudflare, but it served its search pages to plain requests every time it was tested. If you get exit code 3, the likeliest cause is a datacenter address. Try a proxy or the Browser API.

Why doesn't the multiple match my own calculation?
The card rounds monthly profit, and the multiple is Flippa's own figure. The scraper reports it as published.

Can I get the full listing details, like traffic or the P&L?
Not with this scraper. It reads search and category cards, and detailed financials are on the individual listing pages, which it doesn't open.

Why are prices in euros?
You scraped /fr/search or /es/search. Those pages convert prices. Use /search for dollars.

Is it legal to scrape Flippa?
The scraper reads public listing pages, doesn't log in and doesn't submit forms. Whether your use is allowed depends on your jurisdiction and Flippa's terms, so check both and keep the pace reasonable. This isn't legal advice.

Wrapping up

If you keep one habit from this guide, make it opening the .meta.json before you trust a file. It tells you whether you got the whole listing or only its first pages, and that matters more on Flippa than any parsing detail.

Getting started: clone the repository and run it with no setup at all. For large volumes or a specific country, sign up for 2Captcha and add residential proxies or the 2Captcha Browser API.

Source code

Documentation