# Microns Startup Listings Scraper — Micro-Startups For Sale (`tactful_anvil/microns-startup-listings-scraper`) Actor

Every micro-startup for sale on microns.io: asking price, annual revenue, revenue multiple, customers, days listed, sold status + market comps, and a 0-100 deal score. HTTP-only, no login. Schedule it daily to catch fresh, fairly-priced deals first.

- **URL**: https://apify.com/tactful\_anvil/microns-startup-listings-scraper.md
- **Developed by:** [Mr Zack](https://apify.com/tactful_anvil) (community)
- **Categories:** Lead generation, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 listing 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Microns Startup Listings Scraper — Micro-Startups For Sale, With The Numbers That Matter

Scrapes **every startup-for-sale listing on [microns.io](https://www.microns.io)** — the marketplace where indie founders sell micro-SaaS, mobile apps, newsletters, YouTube channels, extensions and content sites, typically for $1K–$100K — and turns each one into a decision-ready row:

- **Asking price** and **annual revenue (ARR)** as published
- **`revenueMultiple`** — asking price ÷ ARR, the number every acquirer computes by hand before anything else
- **`dealScore` (0–100)** — fresh, fairly-priced, revenue-verified deals rank first
- **`status`** — `available` or `sold`. Sold listings are free **market comps**: what multiples actually clear, not what sellers wish for
- Customers, price per customer, publish date + **days listed**, founded year, business model, expenses, growth opportunity, **reason for selling**, asking-price reasoning, target audience, competitors, tech stack, and the listing URL

HTTP-only, no login, no browser, no proxies. Pay per result — a filtered run costs cents.

### Who is this for?

- **Micro-acquirers & flippers** hunting underpriced deals before they're gone — the good ones sell in days, and refreshing the site by hand is exactly the work this replaces
- **Investors & analysts** benchmarking micro-startup valuations (median multiples by category, from *sold* comps)
- **Founders** pricing their own exit against what's actually listed and what actually sold
- **Newsletter operators & deal-flow services** feeding "best deals this week" digests

### Output fields

| Field | Description |
|---|---|
| `name`, `category`, `description` | What the startup is (e.g. Micro-SaaS, Mobile App, YouTube, Newsletter) |
| `status` | `available` (still buyable) or `sold` |
| `askingPriceUsd` / `askingPriceRaw` | Asking price |
| `arrUsd` / `arrRaw` | Annual revenue. `$0` = pre-revenue (a real zero); `null` = not published — never confused |
| `revenueMultiple` | askingPriceUsd ÷ arrUsd; `null` when ARR is 0 or unknown, never a fake value |
| `customers`, `pricePerCustomer` | Traction and what you'd pay per customer |
| `publishedDate`, `daysListed` | How long it's been on the board — fresh deals go fast |
| `foundedYear` | Year the startup was founded |
| `dealScore` | 0–100 for available listings: revenue evidence (35, log-scaled ARR) + price fairness (30, vs the standard ~3x ARR yardstick) + traction (15) + freshness (20). Unknowns score neutral, never bonus. Sold = `null` |
| `businessModel`, `expenses`, `growthOpportunity` | The seller's own operating notes |
| `reasonForSelling`, `askingPriceReasoning` | Why they're selling and how they priced it |
| `targetAudience`, `competitors`, `techStack` | Context for diligence |
| `url` | Direct link to the listing |

### Input

| Option | Default | What it does |
|---|---|---|
| `listingStatus` | `available` | `available`, `sold` (market comps), or `all` |
| `category` | – | Substring filter, e.g. `SaaS`, `YouTube`, `Newsletter` |
| `minArrUsd` | – | Require published revenue (use `1` for "any revenue at all") |
| `maxAskingPriceUsd` | – | Your budget cap |
| `maxRevenueMultiple` | – | e.g. `3` = only fairly-priced deals |
| `sortBy` | `dealScore` | `dealScore`, `newest`, `askingPrice`, `revenueMultiple`, `arr` |
| `maxItems` | 1000 | Caps rows pushed = caps your cost |

Every run also writes a `SUMMARY` key-value record: board totals, available vs sold, median revenue multiple, new-this-week count and the top 5 deals.

### How to schedule this Actor (the whole point)

New listings appear weekly and the good ones go fast — this board is only useful **fresh**:

1. Open the Actor → **Schedules** tab → **Create new schedule**
2. Cadence: **daily** (e.g. `@daily`) for deal-hunting, weekly for valuation benchmarking
3. Input preset for a daily deal alert: `{ "listingStatus": "available", "minArrUsd": 1, "maxRevenueMultiple": 4, "sortBy": "dealScore" }`
4. Add an [integration](https://docs.apify.com/platform/integrations) (Slack, email, webhook, Make, Zapier) to push new top deals straight to you
5. Compare `daysListed` between runs — anything that vanished from `available` either sold or was pulled

Tip for valuation work: run `listingStatus: "sold"` weekly and track `medianRevenueMultiple` from the `SUMMARY` — that's a live micro-startup valuation index no one publishes.

### Fair use & data notes

- Public data only, fetched politely (small concurrency + delay). No login, no paywall bypass.
- Deal terms change and sellers update listings — always verify on the listing page before contacting a founder. This dataset is decision support, not financial advice.

### Was this Actor useful?

If it saved you a manual morning refresh, a ⭐ review on the Store page helps other acquirers find it. Hit a problem or want a field added? Open an **Issue** — the parser is monitored and actively maintained.

# Actor input Schema

## `listingStatus` (type: `string`):

Which listings to return. "available" (default) = deals you can still buy; "sold" = market comps for what multiples actually clear; "all" = the whole board.

## `category` (type: `string`):

Case-insensitive substring filter on the listing category, e.g. "SaaS", "YouTube", "Mobile App", "Newsletter", "Extension".

## `minArrUsd` (type: `integer`):

Only listings with published annual revenue at or above this amount. Use 1 to require any verified revenue at all.

## `maxAskingPriceUsd` (type: `integer`):

Only listings priced at or below your budget.

## `maxRevenueMultiple` (type: `integer`):

Only listings asking at or below this multiple of annual revenue (e.g. 3 = fairly priced by the standard micro-SaaS yardstick). Listings without revenue are excluded when set.

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

dealScore (default) ranks fresh, fairly-priced, revenue-verified deals first; newest = latest listings; askingPrice = cheapest first; revenueMultiple = best-priced first; arr = biggest revenue first.

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

Cap on the number of listings pushed to the dataset (caps your per-result cost).

## Actor input object example

```json
{
  "listingStatus": "available",
  "sortBy": "dealScore",
  "maxItems": 1000
}
```

# Actor output Schema

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

One row per startup listing: asking price, annual revenue, revenue multiple, customers, publish date + days listed, sold status and a 0-100 deal score.

# 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("tactful_anvil/microns-startup-listings-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("tactful_anvil/microns-startup-listings-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 '{}' |
apify call tactful_anvil/microns-startup-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tactful_anvil/microns-startup-listings-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/Mqz44QKBHwHJMy0Bo/builds/cIZGP0A8cx3Pr4Tuk/openapi.json