# Acquire.com Scraper — Startup Marketplace Listings (`khadinakbar/acquire-com-scraper`) Actor

Scrape Acquire.com startup listings for sale: asking price, multiples, TTM revenue & profit, growth, category, tech stack, trust signals. Filters by category, price, revenue, profit, keywords. MCP-ready.

- **URL**: https://apify.com/khadinakbar/acquire-com-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 listing scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What this Actor does

Micro-PE buyers, search funds, M\&A advisors, and AI agents use this Actor to extract **Acquire.com startup marketplace listings** into a clean dataset: asking price, revenue and profit multiples, TTM revenue and profit, last-month revenue, ARR, annual growth, customers, category, location, tech stack, business model, selling reasons, financing options, and seller trust signals (P\&L documents, recast financials, Guided by Acquire). It reads the public listing sitemap and public listing pages over plain HTTP — no Acquire.com account, cookies, or login required.

| Data group | Fields you receive |
| --- | --- |
| Deal terms | `askingPrice`, `currency`, `revenueMultiple`, `profitMultiple`, `askingPriceReasoning`, `isPriceReduced` |
| Financials | `ttmRevenue`, `ttmProfit`, `lastMonthRevenue`, `lastMonthProfit`, `arr`, `annualGrowthRatePct`, `metrics{}` |
| Business profile | `title`, `category`, `location`, `dateFounded`, `teamSize`, `businessModel[]`, `techStack[]`, `customers`, `churnRate` |
| Seller story | `description`, `sellingReasons[]`, `growthOpportunities[]`, `competitors[]`, `keyAssets[]`, `financing[]` |
| Trust signals | `pnlDocumentCount`, `supportingFileCount`, `hasRecastFinancials`, `isGuidedByAcquire`, `hasTrustSignal`, `badges[]` |
| Provenance | `listingId`, `url`, `lastModified`, `dataAccessLevel`, `source`, `scrapedAt` |

### Best fit for this Actor

- Build a deal-flow feed of SaaS, Ecommerce, Mobile, Shopify App, AI, Agency, Content, and Marketplace businesses for sale
- Screen listings by asking price, TTM revenue, and TTM profit before opening them in a browser
- Rank the scanned set by lowest revenue or profit multiple, highest revenue, or lowest price
- Keep only listings that show seller trust signals (P\&L documents, recast financials, or Guided by Acquire)
- Refresh specific listings you already track by pasting their URLs or 10-character IDs

This Actor is designed for the public listing preview that every visitor sees. When your thesis also needs the investors behind a category, continue with [Startup Investors Scraper](https://apify.com/khadinakbar/startup-investors-scraper). For accelerator-backed companies to compare against marketplace listings, pair it with [Y Combinator Scraper](https://apify.com/khadinakbar/ycombinator-scraper). For newly launched products that may become acquisition targets later, use [Product Hunt Scraper Pro](https://apify.com/khadinakbar/producthunt-scraper-pro).

### Practical scenario

A search-fund analyst wants profitable SaaS businesses under $500k. She selects the `SaaS` category, sets `maxAskingPrice` to `500000`, `minProfit` to `1`, sorts by `profitHighToLow`, and schedules the Actor every morning. Each pass scans the most recently updated public listings, keeps the matches, and returns them ranked by TTM profit. She then exports the dataset to a spreadsheet, compares multiples against her target range, and opens the top listings on Acquire.com to request access.

### Quick start input

```json
{
  "categories": ["SaaS"],
  "maxAskingPrice": 500000,
  "minProfit": 1,
  "sortBy": "profitHighToLow",
  "maxItems": 10,
  "maxListingsToScan": 300
}
```

Refresh known listings instead of scanning the catalog:

```json
{
  "startUrls": [
    { "url": "https://app.acquire.com/public/oa2pfifwmk-high-traffic-social-app-with-1-000-000-down" },
    { "url": "https://app.acquire.com/startup/8m6f9n3zlz" }
  ]
}
```

### Input reference

| Field | What it controls |
| --- | --- |
| `startUrls[]` | Optional Acquire.com listing URLs (`/public/...`, `/startup/...`) or 10-character listing IDs. When set, only these listings are fetched. |
| `maxItems` | Maximum listings saved and billed (default 20, prefill 3) |
| `categories[]` | SaaS, Ecommerce, Mobile, Shopify App, AI, Agency, Content, Marketplace, Digital, Main Street, Other |
| `keywords[]` | Match words in the title or description; listings with matching URL slugs are scanned first |
| `minAskingPrice` / `maxAskingPrice` | Asking price range in USD |
| `minRevenue` / `maxRevenue` | TTM revenue range in USD |
| `minProfit` / `maxProfit` | TTM profit range in USD (negative values allowed) |
| `sortBy` | `recentlyUpdated`, `oldestUpdated`, `askingPriceLowToHigh`, `askingPriceHighToLow`, `revenueHighToLow`, `profitHighToLow` |
| `hideUnderOffer` | Skip listings marked under offer or unavailable (default true) |
| `verifiedOnly` | Keep only listings with a trust signal: P\&L documents, recast financials, or Guided by Acquire |
| `maxListingsToScan` | How many public listings to inspect (default 300). It also caps direct URLs. Value sorts rank within this scanned set. |
| `proxyConfiguration` | Direct requests by default. Set an Apify Proxy explicitly when your permitted workflow needs it; proxy usage costs extra. |

### What data you receive

One dataset item is one public Acquire.com listing.

```json
{
  "listingId": "oa2pfifwmk",
  "url": "https://app.acquire.com/public/oa2pfifwmk-high-traffic-social-app-with-1-000-000-down",
  "title": "High Traffic Social App with 1,000,000+ Downloads",
  "category": "Mobile",
  "location": "Cyprus",
  "askingPrice": 100000,
  "currency": "USD",
  "revenueMultiple": 0.3,
  "profitMultiple": 1.2,
  "annualGrowthRatePct": 974,
  "ttmRevenue": 351000,
  "ttmProfit": 80600,
  "customers": "5,000+ paying users",
  "techStack": ["React Native"],
  "pnlDocumentCount": 1,
  "hasRecastFinancials": false,
  "isGuidedByAcquire": false,
  "hasTrustSignal": true,
  "isUnderOffer": false,
  "lastModified": "2026-09-28T00:00:00.000Z",
  "dataAccessLevel": "PUBLIC_PREVIEW",
  "source": "acquire.com",
  "scrapedAt": "2026-09-30T08:00:00.000Z"
}
```

| Field | Meaning |
| --- | --- |
| `askingPrice` / `currency` | Seller's asking price from the listing's structured data |
| `revenueMultiple` / `profitMultiple` | Multiples shown on the listing (`null` when the listing omits one) |
| `ttmRevenue` / `ttmProfit` | Trailing-twelve-month revenue and profit in USD |
| `annualGrowthRatePct` | Annual growth rate shown on the listing |
| `metrics` | Every metric card label and value exactly as displayed |
| `hasTrustSignal` | `true` when the listing has P\&L documents, recast financials, or Guided by Acquire |
| `dataAccessLevel` | Always `PUBLIC_PREVIEW` — the public view any visitor sees |

Download JSON, CSV, or Excel from the dataset. The key-value store records `OUTPUT` and `RUN_SUMMARY` report the outcome (`COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, `UPSTREAM_FAILED`, or `CONFIG_ERROR`) plus scan statistics and charged event counts.

### Use through the API

```bash
curl "https://api.apify.com/v2/acts/khadinakbar~acquire-com-scraper/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"categories":["SaaS"],"maxAskingPrice":500000,"sortBy":"profitHighToLow","maxItems":10}'
```

Read rows from the `defaultDatasetId` once the status is SUCCEEDED, then check `OUTPUT.outcome` in the default key-value store.

### Use with AI agents through Apify MCP

> Find up to five profitable SaaS businesses for sale on Acquire.com under $300k, ranked by highest TTM profit. Return title, asking price, TTM revenue, TTM profit, multiples, and the listing URL.

Keep `maxItems` small for agent calls, read `OUTPUT.outcome` to confirm the result type, and keep `url` plus `scrapedAt` as provenance for each listing. In the [Apify MCP integration](https://docs.apify.com/integrations/mcp), discover the Actor, read its input schema, then call it with the explicit Actor identity and complete input. Read the resulting run and dataset handles to retrieve rows. Hosted-client execution is a separate check from the REST tests.

### Pricing

This Actor uses Pay per event plus Apify platform usage. The live Pricing tab is the current source of truth.

- `apify-actor-start`: $0.00005 per start
- `listing-scraped`: $0.0015 per saved listing

Ten saved listings cost one start event plus ten `listing-scraped` events ($0.01505 before platform usage). Only saved listings are billed — `VALID_EMPTY` and `INVALID_INPUT` outcomes charge no listing events.

Each complete record is validated before a serialized SDK write-and-event call. Concurrent fetches share a single result limit, and the named listing event is counted separately from synthetic SDK events. A caller charge cap can stop a run with `PARTIAL` output. Platform compute, proxy traffic and storage remain additional costs.

If a run is resurrected, it preserves its existing dataset and stops with an actionable diagnostic instead of replaying writes and charges. Review those rows and charges, then start a fresh run if more listings are needed. Transparent checkpoint continuation and cross-run change tracking are outside this version's scope.

### Best results

- Start with the prefill (three listings) to confirm the fields match your workflow, then raise `maxItems`.
- Combine a category with price, revenue, or profit ranges for a focused deal feed.
- Raise `maxListingsToScan` for narrow filters or value sorts so more of the catalog is ranked.
- Use `startUrls` to refresh listings you already track; it is the quickest mode.
- Schedule the Actor daily with `sortBy: recentlyUpdated` to catch new and edited listings first.

### Builder's note

I built this after mapping Acquire.com's public surface. I found that every public listing is in the sitemap with a last-modified date, and each listing page renders its financial metric cards, tech stack, and trust badges server-side alongside structured product data. That made a lean HTTP-only design possible: no browser, no account, and a clear public-preview contract. Seller identity and the data room stay behind Acquire's NDA flow, so the dataset focuses on the deal metrics buyers use to decide which listings to open.

### Responsible use

Use this Actor only with permission covering your collection and intended data use. Acquire.com's Terms of Use prohibit automated access; public availability alone does not grant collection permission. Confirm important figures with the seller through Acquire.com before any transaction. This Actor reads public pages only and leaves seller identity, NDA-gated data rooms, and account features untouched.

"Acquire.com" is a trademark of its owner. This independent Actor is not affiliated with, associated with, or endorsed by Acquire.com.

# Changelog

This Actor's version history is a separate document: https://apify.com/khadinakbar/acquire-com-scraper/changelog.md

# Actor input Schema

## `startUrls` (type: `array`):

Scrape specific Acquire.com listings. Paste public listing URLs such as https://app.acquire.com/public/<id>-<slug>, https://app.acquire.com/startup/<id>, or a bare 10-character listing ID. Leave empty to browse the full public catalog from the Acquire.com sitemap with the filters below.

## `maxItems` (type: `integer`):

Hard cap on listings saved to the dataset and billed. Each saved listing is one listing-scraped event. Use 3 for a quick test, 50–200 for deal sourcing, up to 1500 for a full catalog export.

## `categories` (type: `array`):

Keep only listings in these Acquire.com categories. Leave empty for all categories.

## `keywords` (type: `array`):

Keep only listings whose title, description, tech stack, or business model contains at least one keyword (case-insensitive), e.g. \["shopify", "b2b", "ai"]. Leave empty to keep everything.

## `minAskingPrice` (type: `integer`):

Keep only listings with an asking price at or above this USD amount. Leave empty for no minimum.

## `maxAskingPrice` (type: `integer`):

Keep only listings with an asking price at or below this USD amount. Leave empty for no maximum.

## `minRevenue` (type: `integer`):

Keep only listings whose trailing-twelve-month (TTM) gross revenue is at or above this USD amount. Listings without public revenue are excluded when set.

## `maxRevenue` (type: `integer`):

Keep only listings whose TTM gross revenue is at or below this USD amount.

## `minProfit` (type: `integer`):

Keep only listings whose TTM net profit is at or above this USD amount. Use 1 to keep only profitable startups. Negative values are allowed.

## `maxProfit` (type: `integer`):

Keep only listings whose TTM net profit is at or below this USD amount.

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

recentlyUpdated / oldestUpdated order by the sitemap last-modified date and stream results as they are found. Price, revenue, and profit sorts rank all matches inside the scanned set before saving the top maxItems.

## `hideUnderOffer` (type: `boolean`):

Skip listings that Acquire.com marks as no longer available (under offer / LOI) on the public page.

## `verifiedOnly` (type: `boolean`):

Keep only listings that show a public trust signal on Acquire.com: attached P\&L documents, recast financials, or the Guided by Acquire badge.

## `maxListingsToScan` (type: `integer`):

Limit public listing pages inspected in either catalog or direct URL mode. Value sorts rank within this scanned set. Direct URLs beyond this cap are skipped with PARTIAL output. Scanned but unmatched pages have no listing event charge.

## `proxyConfiguration` (type: `object`):

Use direct HTTPS requests by default for lower cost. Explicitly enable an Apify Proxy when needed for your authorized collection. Direct mode does not silently add residential fallback charges. Proxy bytes and other platform usage are charged in addition to listing events.

## Actor input object example

```json
{
  "startUrls": [],
  "maxItems": 3,
  "categories": [],
  "keywords": [],
  "sortBy": "recentlyUpdated",
  "hideUnderOffer": true,
  "verifiedOnly": false,
  "maxListingsToScan": 300,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per public Acquire.com listing: title, category, location, asking price, revenue/profit multiples, TTM and last-month revenue/profit, growth, customer metrics, tech stack, business model, competitors, key assets, trust signals, URL, and scrape time.

## `summary` (type: `string`):

Terminal outcome, itemsPushed, charged listing-scraped count, estimated event cost, and scan statistics.

## `runSummary` (type: `string`):

Same terminal outcome record stored at RUN_SUMMARY.

# 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 = {
    "startUrls": [],
    "maxItems": 3,
    "categories": [],
    "keywords": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/acquire-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 = {
    "startUrls": [],
    "maxItems": 3,
    "categories": [],
    "keywords": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/acquire-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 '{
  "startUrls": [],
  "maxItems": 3,
  "categories": [],
  "keywords": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call khadinakbar/acquire-com-scraper --silent --output-dataset

```

## MCP server setup

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