# Flippa Business Search & Financial Export (`jpmarketdata/flippa-business-search-financial-export`) Actor

Export multiple Flippa business searches and public listings. Compare asking price, monthly revenue/profit, displayed multiples and verification labels with separate source evidence and annual calculations. No login or seller contacts.

- **URL**: https://apify.com/jpmarketdata/flippa-business-search-financial-export.md
- **Developed by:** [h ichi](https://apify.com/jpmarketdata) (community)
- **Categories:** Automation, Developer tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.80 / 1,000 business listing exporteds

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Flippa Business Search & Financial Export

Export multiple Flippa business searches and public listings. Compare asking price, monthly revenue/profit, displayed multiples and verification labels with separate source evidence and annual calculations. No login or seller contacts.

### Input

Use public URLs from the listed source paths. An empty input applies these defaults:

```json
{
  "searchUrls": [
    "https://flippa.com/buy/sitetype/saas",
    "https://flippa.com/buy/monetization/ecommerce"
  ],
  "listingUrls": [],
  "maxListings": 100,
  "maxPagesPerSearch": 2,
  "includeDetails": true,
  "maxRequests": 200,
  "minMonthlyProfit": 0,
  "maxAskingPrice": 0
}
```

- `searchUrls`: Up to 10 public /buy/ or /search URLs. Retain public platform query conditions; no login, bids, offers, watches, users or financial-evidence endpoints. Default: `["https://flippa.com/buy/sitetype/saas", "https://flippa.com/buy/monetization/ecommerce"]`.
- `listingUrls`: Up to 20 public listing URLs starting with a numeric listing ID. Set searchUrls=\[] for direct listings only. Same-host safe redirects are rechecked against robots. Default: `[]`.
- `maxListings`: Global unique listing cap. Each seed gets its first page and rows are interleaved before applying the cap. Default: `100`.
- `maxPagesPerSearch`: Maximum public search pages per seed; follow pagination hrefs. Distinct pages contain 50 listings locally. Default: `2`.
- `includeDetails`: Fetch public listing pages to reconcile asking price/status and visible verification evidence. No authenticated monthly financial breakdown, seller profile or NDA data. Default: `true`.
- `maxRequests`: Global cap including robots, public detail pages and redirects. A limit reports explicit partial coverage; an upstream failure fails the run. Default: `200`.
- `minMonthlyProfit`: Local filter in source listing currency; 0 disables this filter. Unknown values remain missing and are excluded if filtering is enabled. Use single-currency searches for meaningful numeric filtering. Default: `0`.
- `maxAskingPrice`: Local source-currency filter; 0 disables. Unknown prices are excluded when enabled. This cap is on asking price, not sold value or total acquisition costs. Default: `0`.

### Output

One unique `business_listing` row is delivered per qualifying record. `rowType`: Always business_listing. `listingId`: Original numeric Flippa listing ID. `listingUrl`: Canonical public listing URL. `title`: Published business title or category heading when the name is confidential. `businessType`: Public SaaS/ecommerce/app/domain/etc type. `currency`: Explicit published price currency, when available; never inferred from geography. `askingPrice`: Public asking price, not a completed sale price. `monthlyRevenue`: Source-listed monthly revenue; seller/platform claim, not audited truth. `monthlyProfit`: Source-listed monthly profit; omitted when private/undisclosed. `displayedProfitMultiple`: Platform-displayed multiple retained independently from our calculation. `displayedMultiplePeriod`: Explicit monthly/annual denominator if published; otherwise unspecified. `calculatedAnnualProfitMultiple`: askingPrice/(monthlyProfit\*12) only when same currency, public positive monthly profit and asking price exist. `reduced`: True only if a source price-reduced label is present. `verificationLabels`: Literal public Data Verified/Vetted/integration labels. These are platform claims, not independent verification by this Actor. `status`: Published listing status, when available. `financialEvidence`: Per-field raw label, raw value, source URL and claim source; calculation evidence uses a separate method/formula. `sourceUrls`: Public input/result pages supporting this record. `observedAt`: UTC ISO 8601 observation time. `coverage`: Requested limits, scanned pages, available source counts, actual delivered count and truncation reason. Source ordering is not a quality ranking. `availability`: Availability of optional fields; missing public values are omitted, never invented as zero.

Unavailable optional values are omitted and described in `availability`; an unknown numeric value is never zero. `coverage` distinguishes delivered rows, source totals, page limits and incomplete scope. Calculated fields have their own source/formula evidence.

### Limits

Retain source search order and public filters. Interleave seeds. Multiples are comparison observations, not investment advice or a valuation ranking.

Only public HTTP/JSON acquisition is supported; exact-host HTTPS URLs and redirects are checked against robots before requests. At most 1,000 requests per run, including redirects/robots, and 30 seconds per request. Searches and pagination remain serial; up to three public detail requests may be active. A shared per-origin gate starts all source requests at least one second apart and honors a larger robots Crawl-delay. Failed detail groups are cancelled and joined before the run fails; every selected detail validates before any paid rows are delivered. The Actor keeps a 300-second ceiling, with 270 seconds for acquisition and 20 seconds for delivery; a phase timeout fails explicitly. The schema bounds and input limits stop before unbounded work. No automatic retries are performed. A user cap produces an explicitly bounded prefix; upstream auth, rate limit, structural changes and timeouts fail the run. Zero qualifying records fail; no empty success or valuable-negative substitute. The Actor uses 256 MB and no paid external API or residential proxy.

### Pricing

$0.0008 per unique listing including public detail reconciliation, with no start or detail add-on. The default100-listing cap costs at most$0.08; the maximum200-listing cap costs at most$0.16 in Actor fees. Bill only `listing-exported` after delivery of one qualifying unique dataset row. Excluded, duplicate and failed-request rows are not charged. This pricing is an initial hypothesis; measured private cloud cost and real PPE parity remain release gates.

### Privacy

Only public business-listing facts are extracted. Seller profiles, contact fields, private financial evidence, credentials and cookies are excluded. Embedded email/phone strings in business text and financial evidence are redacted. Free-form source text can contain incidental self-disclosure; output is not promised perfectly anonymous. No account/login/cookie input is accepted.

### AI agent use

Ask to compare selected SaaS or ecommerce businesses by public asking price, monthly revenue/profit and verification claims. Provide public search/listing URLs and limits, then use `financialEvidence`, `coverage` and `availability` to assess the observations. Published finances and badges are seller/platform claims, not audited evidence or our valuation.

### Paid row validity

A billable listing requires nonempty listingId, canonical listingUrl, title/businessType and at least one observed public askingPrice, monthlyRevenue or monthlyProfit with nonempty financialEvidence. Metadata-only, no-financial-value and guessed-identity rows are invalid and never charged.

### Resource and billing safeguards

Requests use the stated jpmarketdata crawler User-Agent and matching merged robots rules, including source Crawl-delay. Streaming bounds are4MiB wire/decoded per page, at most three bounded response bodies in flight,128MiB total transfer and24MiB staged output. Atomic request reservations include robots and redirects in the user request cap. A request-cap prefix includes only completed, validated detail groups. Unsupported compression, excessive bodies, private redirects, contacts in URLs and authentication parameters fail safely. Public text and financial evidence redact embedded email/phone strings. Spending allowance is checked before any delivery; an insufficient allowance fails without output or fees. SDK delivery uses batches of at most 50 validated listings, with one listing-exported event per delivered row and actual returned charged-count checks. Failure diagnostics retain only request classes, counts, status and numeric Retry-After; no source URLs, bodies or personal data.

# Actor input Schema

## `searchUrls` (type: `array`):

Up to 10 public /buy/ or /search URLs. Retain public platform query conditions; no login, bids, offers, watches, users or financial-evidence endpoints. $0.0008 per delivered listing.

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

Up to 20 public listing URLs starting with a numeric listing ID. Set searchUrls=\[] for direct listings only. Same-host safe redirects are rechecked against robots. $0.0008 per delivered listing.

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

Global unique listing cap. Each seed gets its first page and rows are interleaved before applying the cap. $0.0008 per delivered listing.

## `maxPagesPerSearch` (type: `integer`):

Maximum public search pages per seed; follow pagination hrefs. Distinct pages contain 50 listings locally. $0.0008 per delivered listing.

## `includeDetails` (type: `boolean`):

Include public listing pages to reconcile asking price/status and visible verification evidence. No authenticated monthly financial breakdown, seller profile or NDA data. Public details are included in the per-listing fee. $0.0008 per delivered listing.

## `maxRequests` (type: `integer`):

Global request cap including robots, public details, redirects and bounded retries. A limit reports explicit partial coverage; an upstream failure fails the run. Charges ($) apply only to valid delivered listings; this cap can reduce output and fees. $0.0008 per delivered listing.

## `minMonthlyProfit` (type: `number`):

Local filter in source listing currency; 0 disables this filter. Unknown values remain missing and are excluded if filtering is enabled. Use single-currency searches for meaningful numeric filtering. $0.0008 per delivered listing.

## `maxAskingPrice` (type: `number`):

Local source-currency filter; 0 disables. Unknown prices are excluded when enabled. This cap is on asking price, not sold value or total acquisition costs. $0.0008 per delivered listing.

## Actor input object example

```json
{
  "searchUrls": [
    "https://flippa.com/buy/sitetype/saas",
    "https://flippa.com/buy/monetization/ecommerce"
  ],
  "listingUrls": [],
  "maxListings": 100,
  "maxPagesPerSearch": 2,
  "includeDetails": true,
  "maxRequests": 200,
  "minMonthlyProfit": 0,
  "maxAskingPrice": 0
}
```

# Actor output Schema

## `results` (type: `string`):

One delivered listing per row with published business data and source links.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/flippa-business-search-financial-export").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/flippa-business-search-financial-export").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call jpmarketdata/flippa-business-search-financial-export --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jpmarketdata/flippa-business-search-financial-export"
        }
    }
}
```

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/OIGIEcEIthsVu6qxG/builds/AQ0h0IPA5bpGBAeyV/openapi.json