# Acquire Startup Listings Extractor (`kawsar/acquire-startup-listings-extractor`) Actor

Acquire.com scraper that pulls public startup listings with asking price, TTM revenue, profit, multiples and growth, so buyers and investors can track new SaaS and ecommerce deals without copying numbers by hand.

- **URL**: https://apify.com/kawsar/acquire-startup-listings-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 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

## Acquire Startup Listings Extractor: Scrape Startups for Sale from Acquire.com

Acquire Startup Listings Extractor is an Acquire.com scraper that turns the startup marketplace into structured data. For every public listing it collects the asking price, TTM revenue and profit, valuation multiples, growth rate, customer metrics, tech stack, and the reason the founder is selling. You don't need an Acquire.com account, cookies, or a browser extension.

Acquire.com usually has about 1,200 startups for sale at any moment, and the list changes every day. Reading them one at a time is slow, and comparing them in a spreadsheet is worse. This actor does the collecting for you, so you can sort by revenue multiple, filter by business type, and get new deals in Google Sheets, Slack, or your CRM on a schedule.

### What is Acquire.com?

[Acquire.com](https://acquire.com) (formerly MicroAcquire) is one of the largest marketplaces for buying and selling bootstrapped and venture-backed startups. Founders list SaaS products, ecommerce stores, mobile apps, agencies, AI tools, newsletters, and Shopify apps, usually priced from a few thousand dollars up to several million. Each listing shows headline financials publicly, while the seller's identity and data room stay private until a buyer requests access.

### Why use this Acquire.com scraper?

- **No login needed.** It reads only what Acquire.com shows publicly, so there's no session export, cookie copying, or account risk.
- **Financials as numbers, not text.** `$1.2M` becomes `1200000` and `+974%` becomes `974`, so you can sort and chart straight away.
- **Filter before you pay.** Type, price, revenue, profit, and keyword filters run inside the actor. Listings you don't want never reach your dataset.
- **Fresh deals first.** The default Newest First order starts with the most recently updated listings, which suits daily monitoring.
- **Built for cost control.** Max Items, a run timeout, and a per-request timeout keep every run predictable.

### What data does it extract?

| Group | Fields |
|-------|--------|
| Listing | `listingId`, `url`, `headline`, `businessType`, `location`, `lastModified` |
| Price and valuation | `askingPrice`, `askingPriceText`, `currency`, `profitMultiple`, `revenueMultiple`, `askingPriceReasoning` |
| Financial performance | `ttmRevenue`, `ttmProfit`, `lastMonthRevenue`, `lastMonthProfit`, `annualGrowthRate` |
| Customer metrics | `arr`, `customersCount`, `churnRate`, plus everything shown on the listing in `customerMetrics` (downloads, MAU, app store rating, SKUs, inventory value and more) |
| Company overview | `dateFounded`, `teamSize`, `businessModel`, `techStack`, `growthOpportunities`, `competitors`, `keyAssets` |
| Acquisition details | `sellingReasoning`, `financing` |
| Content and documents | `listingDescription`, `plDocumentsCount`, `supportingFilesCount`, `hasGoogleAnalytics` |
| Run info | `scrapedAt` |

The startup's real name, seller contact details, private financials, and data room files are locked on Acquire.com for signed-in buyers, so this actor doesn't return them.

### Supported business types

Pick one in the **Type** dropdown, or leave it on **All**. Approximate share of the marketplace in September 2026:

| Type | Share of listings |
|------|-------------------|
| SaaS | about 48% |
| Ecommerce | about 17% |
| Mobile App | about 10% |
| Agency | about 6% |
| AI | about 5% |
| Marketplace | about 3% |
| Other, Content, Digital, Shopify App | about 2% to 3% each |
| Newsletter, Crypto | under 1% each |

### Use cases

- **Deal sourcing for acquirers**: pull every startup for sale into one table and shortlist targets by price, revenue, and growth.
- **Valuation benchmarking**: compare revenue and profit multiples across SaaS, ecommerce, and mobile to see what similar businesses ask for.
- **Daily deal alerts**: schedule a run every morning with Newest First and send new listings to Slack, email, or Google Sheets.
- **Investor and fund research**: track which categories, tech stacks, and business models are coming to market and at what prices.
- **Brokers and M\&A advisors**: build a searchable database of startups for sale for client matching.
- **Newsletters and content creators**: find interesting startups for sale for a weekly deals roundup.

### How to use it

1. Open the actor in Apify Console and go to the **Input** tab.
2. Set **Max Items** to the number of listings you want (the default is 10).
3. Choose an **Order**: Newest First, Oldest First, or Marketplace Order.
4. Choose a **Type**, or keep **All**.
5. Optionally open **Filters** to set a price range, minimum TTM revenue or profit, or keywords.
6. Click **Start**. Results appear in the **Output** tab within a minute or two for typical runs.
7. Download the data as JSON, CSV, Excel, XML, or HTML, or connect an integration.

### Input

| Field | Key | Type | Default | Description |
|-------|-----|------|---------|-------------|
| Max Items | `maxItems` | integer | `10` | Maximum number of listings to save (1 to 1,000). Skipped listings don't count. |
| Order | `order` | string | `newest` | `newest` (Newest First), `oldest` (Oldest First), or `default` (Marketplace Order). Based on each listing's last update time. |
| Type | `businessType` | string | `all` | `all`, `saas`, `ecommerce`, `mobile`, `agency`, `ai`, `marketplace`, `content`, `digital`, `shopify app`, `newsletter`, `crypto`, or `other`. |
| Keywords | `keywords` | array | empty | Keep listings whose headline or description contains at least one of these words. |
| Min Asking Price (USD) | `minPrice` | integer | none | Skip listings priced below this amount. |
| Max Asking Price (USD) | `maxPrice` | integer | none | Skip listings priced above this amount. |
| Min TTM Revenue (USD) | `minTtmRevenue` | integer | none | Skip listings with lower trailing twelve month revenue. |
| Min TTM Profit (USD) | `minTtmProfit` | integer | none | Skip listings with lower trailing twelve month net profit. |
| Listing URLs | `startUrls` | array | empty | Scrape only these listing URLs. Order and Type are ignored when this is set. |
| Max Concurrency | `maxConcurrency` | integer | `10` | Listing pages fetched in parallel (1 to 50). |
| Run Timeout (seconds) | `timeoutSecs` | integer | `300` | The run stops fetching after this many seconds and keeps what it saved. |
| Request Timeout (seconds) | `requestTimeoutSecs` | integer | `30` | Timeout for each HTTP request. |
| Proxy configuration | `proxyConfiguration` | object | Datacenter (Anywhere) | Proxy type and location for requests. Supports Datacenter, Residential, Special, and custom proxies. Optional. |

When a price, revenue, or profit filter is set, listings that don't show that value publicly are skipped.

#### Example: latest 10 listings of any type

```json
{
    "maxItems": 10,
    "order": "newest",
    "businessType": "all"
}
```

#### Example: profitable SaaS under $500k

```json
{
    "maxItems": 100,
    "order": "newest",
    "businessType": "saas",
    "maxPrice": 500000,
    "minTtmProfit": 20000,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

#### Example: AI startups mentioning "subscription"

```json
{
    "maxItems": 50,
    "businessType": "ai",
    "keywords": ["subscription", "recurring"]
}
```

#### Example: refresh specific listings

```json
{
    "startUrls": [
        "https://app.acquire.com/public/oa2pfifwmk-b2c-speech-therapy-app-for-kids-5-000-customers-300k-arr-974-growth"
    ]
}
```

### Output

Each startup listing becomes one dataset item. Here's a real example, shortened a little:

```json
{
    "listingId": "oa2pfifwmk",
    "url": "https://app.acquire.com/public/oa2pfifwmk-b2c-speech-therapy-app-for-kids-5-000-customers-300k-arr-974-growth",
    "headline": "B2C Speech Therapy App for Kids, 5,000+ Customers, $300K ARR, 974% Growth",
    "businessType": "Mobile",
    "location": "Cyprus",
    "askingPrice": 100000,
    "askingPriceText": "$100k",
    "currency": "USD",
    "profitMultiple": 1.2,
    "revenueMultiple": 0.3,
    "annualGrowthRate": 974,
    "ttmRevenue": 351000,
    "ttmProfit": 80600,
    "lastMonthRevenue": 15400,
    "lastMonthProfit": 10700,
    "arr": null,
    "customersCount": 5000,
    "churnRate": null,
    "customerMetrics": {
        "totalDownloads": null,
        "monthlyActiveUsers": null,
        "appStoreRating": null,
        "payingUsers": "5,000+"
    },
    "dateFounded": "March 2025",
    "teamSize": "Small (2-20)",
    "businessModel": ["Subscription", "Business-to-consumer (B2C)"],
    "techStack": ["React Native"],
    "growthOpportunities": ["Improve conversion rates", "Expand to new markets", "Increase pricing"],
    "competitors": ["Speech Blubs", "Keiki"],
    "keyAssets": ["Mobile application", "Domain", "Brand", "Codebase", "Customers"],
    "sellingReasoning": "Lack of time",
    "financing": "Bootstrapped",
    "listingDescription": "This is a fast-growing speech therapy platform helping parents build children's language skills...",
    "askingPriceReasoning": "Profitable subscription app with a tested funnel, validated cohort retention, and a clean handover...",
    "plDocumentsCount": 1,
    "supportingFilesCount": 0,
    "hasGoogleAnalytics": false,
    "lastModified": "2026-09-23T05:50:10.091Z",
    "scrapedAt": "2026-09-24T09:30:27.614394+00:00"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | Unique listing ID from the URL |
| `url` | string | Public listing URL |
| `headline` | string | Seller-written headline |
| `businessType` | string | SaaS, Ecommerce, Mobile, Agency, AI, Marketplace, Content, Digital, Shopify App, Newsletter, Crypto, or Other |
| `location` | string | Country of the startup |
| `askingPrice` | number | Asking price in USD |
| `askingPriceText` | string | Asking price as displayed, e.g. `$1.2M` |
| `currency` | string | Currency of the asking price |
| `profitMultiple` | number | Asking price divided by TTM net profit |
| `revenueMultiple` | number | Asking price divided by TTM gross revenue |
| `annualGrowthRate` | number | Year-over-year revenue growth in percent |
| `ttmRevenue` | number | Trailing twelve month gross revenue in USD |
| `ttmProfit` | number | Trailing twelve month net profit in USD (can be negative) |
| `lastMonthRevenue` | number | Last month's gross revenue in USD |
| `lastMonthProfit` | number | Last month's net profit in USD |
| `arr` | number | Annual recurring revenue in USD, when shown |
| `customersCount` | number | Customers or paying users (lower bound when the listing shows a range like 1,000-5,000) |
| `churnRate` | number | Churn rate in percent, when shown |
| `customerMetrics` | object | Every customer metric on the listing, as displayed |
| `dateFounded` | string | Month and year founded |
| `teamSize` | string | Team size bracket |
| `businessModel` | array | Business model tags, e.g. Subscription, B2B |
| `techStack` | array | Technologies the product uses |
| `growthOpportunities` | array | Growth ideas listed by the seller |
| `competitors` | array | Competitors named by the seller |
| `keyAssets` | array | Assets included in the sale |
| `sellingReasoning` | string | Why the founder is selling |
| `financing` | string | How the startup was financed |
| `listingDescription` | string | Full listing description |
| `askingPriceReasoning` | string | Seller's explanation of the price |
| `plDocumentsCount` | integer | Number of P\&L documents attached |
| `supportingFilesCount` | integer | Number of supporting files attached |
| `hasGoogleAnalytics` | boolean | Whether Google Analytics traffic data is connected |
| `lastModified` | string | When the listing was last updated on Acquire.com |
| `scrapedAt` | string | When the record was scraped |

If a URL you passed in **Listing URLs** was removed or fails to load, you get a row with `url` and `error` instead. Nothing disappears silently.

#### Dataset views

The Output tab has three ready-made table views:

- **Overview**: headline, type, location, price, revenue, profit, growth, and multiples
- **Financials**: price, TTM and last-month numbers, ARR, customers, churn, and growth
- **Company details**: founded date, team size, business model, tech stack, key assets, selling reason, and financing

### Scheduling and deal alerts

To get new startups for sale every day:

1. Save your input as a task (for example Type set to SaaS and a price range).
2. In Apify Console, open **Schedules** and run the task daily with Order set to **Newest First**.
3. Add an integration to the task: Google Sheets to append rows, Slack or email to get a message, or a webhook to push results into your CRM.

Because Newest First starts with recently updated listings, a small Max Items (20 to 50) is usually enough for a daily check.

### Performance and cost

- The actor processes about 8 to 10 listings per second at the default settings, so 500 listings take roughly a minute and the whole marketplace (about 1,200 listings) about two to three minutes.
- A default run (10 listings, all types) finishes in a few seconds.
- The default memory is 512 MB. Very low memory (128 MB) gives the run only a small slice of CPU and slows it down a lot, so keep 512 MB or more.
- The actor watches the run timeout set in **Run options** and stops a few seconds before it, so the run always ends as Succeeded with everything saved so far.
- With a narrow filter such as Shopify App, the actor may check a few hundred listings to find matches. Only matches are saved, so your dataset stays small.
- Max Items, Run Timeout, and Request Timeout cap how long any run can take.

### Tips

- Start with the defaults to see the data shape, then add filters.
- Use Min TTM Revenue or Min TTM Profit to drop idea-stage and pre-revenue listings.
- Sort the Overview view by `revenueMultiple` to spot listings priced low compared with their revenue.
- If you see request errors on large runs, lower Max Concurrency or switch the proxy to Residential.

### Limitations

- Only publicly visible data is extracted. Startup names, seller details, private metrics, and data rooms need a signed-in Acquire.com buyer account and are not included.
- Sellers choose which metrics to show, so `arr`, `churnRate`, and `customersCount` are empty on some listings.
- Some customer counts are shown as ranges. `customersCount` holds the lower bound and `customerMetrics` keeps the original text.
- The Order setting is based on when a listing was last updated, which is not always the date it was first listed.
- Up to 1,000 listings per run. Use two runs with different Types or Orders to cover the full marketplace.

### FAQ

**Do I need an Acquire.com account to use this scraper?**
No. The actor only reads information Acquire.com shows publicly on each listing page.

**How many startup listings can I get per run?**
Up to 1,000. The marketplace usually has around 1,200 public listings.

**Can I get only SaaS startups under a certain price?**
Yes. Set Type to SaaS and Max Asking Price to your budget. Add Min TTM Profit to skip unprofitable ones.

**Why are ARR and churn empty for some listings?**
Each seller picks which metrics to display. Ecommerce listings usually show SKUs and inventory value, and mobile apps show downloads and paying users. Everything shown is kept in `customerMetrics`.

**How often is the data updated?**
Every run fetches live data from Acquire.com. Schedule the actor to keep your dataset current.

**Is it legal to scrape Acquire.com?**
The actor collects only publicly available business listing data and no personal information. You are responsible for how you use the data. Check Acquire.com's terms and the laws that apply to you, and get legal advice if you're unsure.

**Can I export to Excel or Google Sheets?**
Yes. Download as CSV or Excel from the Output tab, or use the Google Sheets integration to append rows after every run.

### Integrations

Connect Acquire Startup Listings Extractor with other apps and services using [Apify integrations](https://apify.com/integrations). You can integrate with Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive, and many more. You can also use [webhooks](https://docs.apify.com/integrations/webhooks) to trigger actions whenever results are available.

### Support and feedback

Found a bug, a missing field, or a listing that didn't parse correctly? Open an issue on the actor's **Issues** tab in Apify Console and include the listing URL. Feature requests are welcome too.

If you buy, broker, or research online businesses, this Acquire.com scraper turns the marketplace into a spreadsheet you can sort, filter, and check every morning.

# Actor input Schema

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

Maximum number of startup listings to save in this run. Listings that don't match your filters don't count toward this limit.

## `order` (type: `string`):

Which listings to process first. Newest First starts with the most recently updated listings on Acquire.com.

## `businessType` (type: `string`):

Only keep startups of this business type. Choose All to get every type.

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

Only keep listings whose headline or description contains at least one of these words or phrases, one per line. Leave empty to skip this filter.

## `minPrice` (type: `integer`):

Skip listings with an asking price below this amount.

## `maxPrice` (type: `integer`):

Skip listings with an asking price above this amount.

## `minTtmRevenue` (type: `integer`):

Skip listings whose trailing twelve month gross revenue is below this amount.

## `minTtmProfit` (type: `integer`):

Skip listings whose trailing twelve month net profit is below this amount.

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

Scrape only these Acquire.com public listing URLs, one per line. When set, Order and Type are ignored and the whole marketplace is not scanned.

## `maxConcurrency` (type: `integer`):

How many listing pages to fetch in parallel.

## `timeoutSecs` (type: `integer`):

The actor stops fetching new listings after this many seconds and keeps everything saved so far.

## `requestTimeoutSecs` (type: `integer`):

Timeout for each HTTP request.

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

Select proxies to use for requests. Helps avoid IP blocking and rate limits. Datacenter proxies are fastest; Residential proxies are harder to detect.

## Actor input object example

```json
{
  "maxItems": 10,
  "order": "newest",
  "businessType": "all",
  "keywords": [
    "AI",
    "subscription"
  ],
  "minPrice": 50000,
  "maxPrice": 500000,
  "minTtmRevenue": 100000,
  "minTtmProfit": 20000,
  "startUrls": [
    "https://app.acquire.com/public/oa2pfifwmk-b2c-speech-therapy-app-for-kids-5-000-customers-300k-arr-974-growth"
  ],
  "maxConcurrency": 10,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Acquire.com scraper that pulls public startup listings with asking price, TTM revenue, profit, multiples and growth, so buyers and investors can track new SaaS and ecommerce deals without copying numbers by hand.

# 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 = {
    "maxItems": 10,
    "order": "newest",
    "businessType": "all",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/acquire-startup-listings-extractor").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 = {
    "maxItems": 10,
    "order": "newest",
    "businessType": "all",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("kawsar/acquire-startup-listings-extractor").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 '{
  "maxItems": 10,
  "order": "newest",
  "businessType": "all",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call kawsar/acquire-startup-listings-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kawsar/acquire-startup-listings-extractor"
        }
    }
}
```

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/lx7Fsf658576h6csy/builds/edestlYDzh4HScFpc/openapi.json