# Business-for-Sale Deal Monitor: Flippa, BizBuySell (`hamzatrq/deal-flow-monitor`) Actor

Monitor businesses for sale across marketplaces in one deduplicated feed. Pulls listings from Flippa (live) and BizBuySell, normalizes them into one schema, deduplicates across sources, and tracks new listings and price drops — with a hard cost cap.

- **URL**: https://apify.com/hamzatrq/deal-flow-monitor.md
- **Developed by:** [Hamza Tariq](https://apify.com/hamzatrq) (community)
- **Categories:** Lead generation, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 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.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## Business-for-Sale Deal Monitor — businesses for sale across marketplaces

> **Quick Start:** click **Start** with the default input. With zero configuration it pulls
> the latest **businesses for sale** from Flippa (the live source) into one deduplicated,
> monitored feed — no API keys, no setup. Narrow it with `keywords` (e.g. `SaaS`,
> `ecommerce`), a `maxAskingPriceUsd` cap, or a `location` — every filter actually runs.

A deduplicated, monitored feed of **businesses for sale**, normalized into one clean schema.
Whether you call it a business-for-sale **scraper**, an acquisitions **data** **API**, a
deal-flow **feed**, or a listings **monitor**, this actor pulls Flippa today (with a tested
BizBuySell adapter that switches on the moment a residential proxy is configured),
deduplicates across sources, and tracks every deal over time so you see new listings and
price drops the moment they happen.

Built for search funders, lower-mid-market PE acquirers, business brokers, and M&A advisors
who live on deal flow.

### What it does

- **One `Deal` schema** — title, category, location, asking price, revenue (TTM), a
  `verifiedRevenue` flag (true when the marketplace has verified the figure), cash flow / SDE,
  derived multiple, broker, and source link. Ready to unify more marketplaces as they open up.
- **Filters that actually run** — `keywords`, `maxAskingPriceUsd`, and `location` are applied
  to every listing before delivery, so you only pay for and pull the deals you asked for.
- **Deduplicates across sources** so the same business listed in two places is one record.
- **Monitors over time** — on a schedule, it emits only new listings and price/status
  changes, not the whole feed again (so recurring runs stay cheap).
- **Hard cost cap** so a run can never surprise you with a bill.

### Sources (honest status)

This is the maintenance-heaviest actor in the portfolio because the marketplaces are HTML and
several are anti-bot. We ship the sources that work and degrade gracefully on the ones that
block datacenter traffic:

| Marketplace     | Status      | Notes                                                                                      |
| --------------- | ----------- | ------------------------------------------------------------------------------------------ |
| **Flippa**      | Live        | Public JSON API, no auth — the primary working feed.                                       |
| **BizBuySell**  | Anti-bot    | Parser built & tested; skipped when blocked (HTTP 403). Add a residential proxy to enable. |
| Empire Flippers | Unavailable | Retired its public listings API.                                                           |
| BizQuest        | Anti-bot    | HTTP 403 to datacenter clients.                                                            |
| Acquire.com     | Auth-gated  | Listings gated behind login.                                                               |

When a source is blocked, the run logs a clear notice and the rest of the feed still
delivers. We never fabricate listings to fill a blocked source.

### Input

Runs **zero-config**. Optional fields (all applied as live filters, comma-separate for several
terms):

- `keywords` — keep only listings whose title or category matches any term (example:
  `ecommerce` or `saas, hvac`). Case-insensitive.
- `maxAskingPriceUsd` — only keep listings at or below this price; undisclosed prices are
  kept (example: `500000`).
- `location` — keep only listings whose seller location contains this text (example:
  `United States`).
- `maxItems` — upper bound per run (default `100`). The Flippa source paginates to honor this,
  so values above one page (~50) now return more than one page.
- `fullSync` — off by default (incremental monitor). Turn it on to re-emit the entire current
  feed on every run — the one-off scraper / full-export use case rather than scheduled monitoring.
- `maxCostPerRunUsd` — hard cost cap, default `$5`.

### Output

One canonical `Deal` per listing. See `.actor/dataset_schema.json` for the columns; the full
field list is in `src/mapping.ts` (`askingPrice`, `revenueTTM`, `verifiedRevenue`,
`cashFlowSDE`, `multiple`, `broker`, `listingStatus`, `sourceUrl`, …). `verifiedRevenue` is
`true` when the marketplace has verified the revenue figure (Flippa's verified-revenue badge),
so you know which `revenueTTM` numbers to trust.

### Pricing

Pay-per-event: a small start fee plus ~$0.01–0.02 per deal result, with a hard per-run cost
cap on by default. When you run it on a schedule (as a monitor), each run emits and charges
for only the deals that are new or changed since the previous run; the first run emits the
full current feed. Want the complete feed every run instead? Set `fullSync: true`. Actively
maintained — fixes within 24h.

# Actor input Schema

## `keywords` (type: `string`):

Full-text query to focus the feed on a niche — a business type, industry, or term (e.g. SaaS, e-commerce, HVAC). Leave empty for a useful default run of the latest listings across marketplaces.
## `maxAskingPriceUsd` (type: `integer`):

Only keep listings at or below this asking price. Leave empty to include every price (including undisclosed).
## `location` (type: `string`):

Only keep listings whose seller location contains this text (case-insensitive, comma-separate for several). Leave empty to include every location.
## `maxItems` (type: `integer`):

Upper bound on deals returned per run. Lower it to cap cost and run time.
## `maxCostPerRunUsd` (type: `integer`):

Hard ceiling on spend per run — the run stops before exceeding it, so you are never surprised by the bill.
## `fullSync` (type: `boolean`):

By default this runs as an incremental monitor: a repeat run emits only NEW or CHANGED records (and bills only for those). Turn this on to re-emit the entire current dataset every run — the one-off scraper / full-export use case.

## Actor input object example

```json
{
  "keywords": "ecommerce",
  "maxAskingPriceUsd": 500000,
  "location": "United States",
  "maxItems": 100,
  "maxCostPerRunUsd": 5,
  "fullSync": false
}
````

# Actor output Schema

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

Monitor businesses for sale across marketplaces in one deduplicated feed. Pulls listings from Flippa (live) and BizBuySell, normalizes them into one schema, deduplicates across sources, and tracks new listings and price drops — with a hard cost cap.

# 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 = {
    "keywords": "",
    "maxAskingPriceUsd": 0,
    "location": "",
    "maxItems": 100,
    "maxCostPerRunUsd": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("hamzatrq/deal-flow-monitor").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 = {
    "keywords": "",
    "maxAskingPriceUsd": 0,
    "location": "",
    "maxItems": 100,
    "maxCostPerRunUsd": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("hamzatrq/deal-flow-monitor").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "keywords": "",
  "maxAskingPriceUsd": 0,
  "location": "",
  "maxItems": 100,
  "maxCostPerRunUsd": 5
}' |
apify call hamzatrq/deal-flow-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=hamzatrq/deal-flow-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Business-for-Sale Deal Monitor: Flippa, BizBuySell",
        "description": "Monitor businesses for sale across marketplaces in one deduplicated feed. Pulls listings from Flippa (live) and BizBuySell, normalizes them into one schema, deduplicates across sources, and tracks new listings and price drops — with a hard cost cap.",
        "version": "0.0",
        "x-build-id": "QCdl6kAxXaTOj5hbe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hamzatrq~deal-flow-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hamzatrq-deal-flow-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/hamzatrq~deal-flow-monitor/runs": {
            "post": {
                "operationId": "runs-sync-hamzatrq-deal-flow-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/hamzatrq~deal-flow-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-hamzatrq-deal-flow-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Keywords or category",
                        "type": "string",
                        "description": "Full-text query to focus the feed on a niche — a business type, industry, or term (e.g. SaaS, e-commerce, HVAC). Leave empty for a useful default run of the latest listings across marketplaces."
                    },
                    "maxAskingPriceUsd": {
                        "title": "Max asking price (USD)",
                        "type": "integer",
                        "description": "Only keep listings at or below this asking price. Leave empty to include every price (including undisclosed)."
                    },
                    "location": {
                        "title": "Location / country",
                        "type": "string",
                        "description": "Only keep listings whose seller location contains this text (case-insensitive, comma-separate for several). Leave empty to include every location."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "type": "integer",
                        "description": "Upper bound on deals returned per run. Lower it to cap cost and run time.",
                        "default": 100
                    },
                    "maxCostPerRunUsd": {
                        "title": "Max cost per run (USD)",
                        "type": "integer",
                        "description": "Hard ceiling on spend per run — the run stops before exceeding it, so you are never surprised by the bill.",
                        "default": 5
                    },
                    "fullSync": {
                        "title": "Full sync (re-scrape everything)",
                        "type": "boolean",
                        "description": "By default this runs as an incremental monitor: a repeat run emits only NEW or CHANGED records (and bills only for those). Turn this on to re-emit the entire current dataset every run — the one-off scraper / full-export use case.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```