# TrustMRR Scraper — Startup Revenue, MRR & For Sale (`oswaldocarabano/trustmrr-startups-scraper`) Actor

Scrape TrustMRR: verified revenue, MRR, growth and 7 revenue periods per startup, daily and monthly revenue, founder, tech stack, channels, startups for sale with asking price, multiple and price history, and founders. Filter by category, country, MRR or price. No login. Errors are never charged.

- **URL**: https://apify.com/oswaldocarabano/trustmrr-startups-scraper.md
- **Developed by:** [Oswaldo Carabano](https://apify.com/oswaldocarabano) (community)
- **Categories:** Business, Lead generation
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 startup profiles

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

## TrustMRR Scraper — Verified Startup Revenue, MRR & Startups for Sale

Extract **verified startup revenue data from TrustMRR**: total revenue, MRR, growth, revenue for 7 periods, daily and monthly revenue, the founder, tech stack, marketing channels, SEO and app-store data — plus the **TrustMRR marketplace** (startups for sale with asking price, revenue multiple and price history) and **founder profiles**. Every row is a full profile: **121 columns, 74 filled per startup on average** (median 76; measured on all 11,701 startups on 15 Oct 2026).

No login, no account, no API key. Duplicate rows within a run and error rows are **never charged**.

> This actor is not affiliated with, endorsed by, or connected to TrustMRR. It reads public pages only.

### What you get

| Output type | One row per | Highlights |
|---|---|---|
| `startups` (default) | startup matching your filters | Verified total revenue, last-30-day revenue, MRR, active subscriptions, revenue and MRR growth, revenue rank; revenue for the last 24 hours, 7 days, 3, 6 and 12 months; **daily revenue for the last 30 days and monthly revenue since the first sale**; payment provider and verification status; founder (name, X handle, followers, avatar); value proposition, problem, pricing model, target persona, team size, funding; tech stack and marketing channels; Ahrefs Domain Rating; App Store / Google Play data; screenshots; sale listing if any |
| `startup-details` | TrustMRR link or slug you paste | The same full profile for specific startups |
| `for-sale` | startup listed for sale | Everything above **plus** asking price, revenue multiple, first-listed date, **every asking-price change**, listing tier, seller message, offers received and recent page views — ranked like TrustMRR's "best deals" |
| `founders` | founder | Total revenue and MRR across all their startups, X followers, every startup with its metrics, and **monthly revenue since the first sale** |

Optional: **`includeRevenueHistory`** adds the **full daily revenue history** of each startup (every day since tracking began — median 88 days, up to 5,000+ days), with the number of charges per day.

### Filters

All filters can be combined:

- **Categories** (31, e.g. AI, SaaS, Developer Tools, Mobile Apps) and **countries** (121)
- **For sale only**, **MRR**, **total revenue** and **30-day growth** ranges
- **Founder X followers**, **B2B / B2C**, **founding year**
- **Asking price** and **revenue multiple** ranges (marketplace)
- **Payment provider** (Stripe, RevenueCat, Dodo Payments, Polar, Lemon Squeezy, Paddle, Creem, Whop, Superwall, Shopify, App Store)
- **Sort by** total revenue, MRR, growth, newest, or best deals

Filters TrustMRR's own search supports are applied there; country, price, multiple and payment provider are checked on each profile, and startups that do not match are **skipped without charge** — also for `founders`, where only founders of matching startups are returned. With a payment-provider filter, each candidate is first checked on its small Markdown profile (primary and secondary provider), so a run can check up to 100 startups per requested row (at least 1,000): ranked by revenue, the 10th Polar startup is #792 and the 10th Dodo Payments startup #1,015 of 11,701 (15 Oct 2026), and both fill a normal run. Providers under 2% (Creem, Whop, Superwall, Shopify, App Store) can return fewer rows than `maxItems`; the status message says so. Other actor-side filters check up to 25 profiles per requested row (at least 200).

Pasting startup links (or founder handles) with the default output type runs `startup-details` (or `founders`) for exactly those; filters are not applied to pasted links.

### Data quality, measured

Measured on **all 11,701 startups** of the catalog (one full run, 15 Oct 2026; "filled" = not null and not empty):

| Field group | Filled |
|---|---|
| Total revenue, last-30-day revenue, MRR, subscriptions, payment provider, verification, 7 revenue periods, daily revenue (30 days) | 100% |
| Revenue growth (30 days) | 99% |
| Monthly revenue since the first sale · revenue rank | 77% · 75% |
| Description · website · category · founding date · country | 91% · 88% · 88% · 84% · 76% |
| Founder name, X handle, profile | 73% |
| Domain Rating · target audience | 77% · 71% |
| Value proposition · problem solved · pricing model | 66% · 64% · 61% |
| Tech stack · marketing channels · screenshots | 57% · 27% · 60% |
| For sale (n = 2,323): revenue multiple · listing tier · price history · asking price · first-listed date | 100% · 100% · 98% · 98% · 97% |
| For sale: seller message | 55% |
| Full daily revenue history (optional; n = 347 sample) | 86% |

Filled fields per startup row: **minimum 42, median 76, maximum 108 (average 74.1)**; startups for sale: average 83.7.

In 50 test runs on the Apify platform (15 Oct 2026): 50 of 50 succeeded, 3,737 rows, charges equal to rows delivered in every run, 0 duplicates; startup rows averaged 74.5 filled fields (n = 2,935) and for-sale rows 86.0 (n = 770).

### How it compares

Compared with the other TrustMRR actors in the Store as declared in their own schemas and READMEs (15 Oct 2026):

| | This actor | Typical TrustMRR actor |
|---|---|---|
| Fields per startup | 121 columns, 74 filled on average | 7–29 declared |
| Revenue history | 7 periods + 30 daily values + monthly since the first sale in every row; optional full daily history | none, or 30 days in a separate dataset |
| Asking-price history | yes | no |
| Country, payment-provider and multiple filters | yes | rarely |
| Founders with monthly revenue | yes | separate actor, totals only |
| Start fee | $0.00001 | up to $0.50 |
| Error rows charged | never | often (charged as dataset items) |

### Pricing

Pay per event — you pay only for rows delivered:

| Event | Price |
|---|---|
| Startup profile (`startups`, `startup-details`) | **$0.0005** ($0.50 per 1,000) |
| Startup for sale (`for-sale`) | $0.0005 |
| Founder | $0.001 |
| Full daily revenue history (optional, per startup that has history) | $0.0003 |
| Actor start | $0.00001 |

Duplicates within a run, startups skipped by your filters, and error rows (not found, unavailable) are **never charged**. Rows reused from the shared cache (see FAQ) cost the same as live rows and carry `cachedAt`. If you set a maximum cost per run, the actor stops cleanly when it is reached.

### Input examples

The **default input `{}`** returns the top 20 startups by total revenue. Default input `{}`: 20 startups in 6–10 seconds (measured on 15 Oct 2026, fetched live; 4 seconds when the profiles were fetched by a recent run).

Top AI startups for sale under $50,000 with at most a 2x multiple:

```json
{
  "outputType": "for-sale",
  "categories": ["ai"],
  "maxAskingPrice": 50000,
  "maxMultiple": 2,
  "maxItems": 100
}
```

Fast-growing B2B SaaS startups with at least $1,000 MRR, with full daily revenue:

```json
{
  "categories": ["saas"],
  "targetAudience": "B2B",
  "minMrr": 1000,
  "minGrowth30d": 20,
  "includeRevenueHistory": true,
  "maxItems": 200
}
```

Specific startups:

```json
{ "outputType": "startup-details", "startupUrls": ["https://trustmrr.com/startup/datafast", "pinpoint"] }
```

Founders:

```json
{ "outputType": "founders", "founders": ["marclou", "https://x.com/someone"] }
```

### Output

One row type per run in the default dataset, with views for an overview, revenue detail, for-sale listings, product and go-to-market, and founders. All money fields are in USD (`currency: "USD"`), dates are ISO 8601, and missing values are explicit `null`. The run also writes `ERRORS` (always present, empty when nothing failed) and `RUN_SUMMARY` (delivered, charged, duplicates, filtered, errors) to the key-value store.

Example (shortened):

```json
{
  "_type": "startup",
  "slug": "pinpoint",
  "name": "PinPoint",
  "url": "https://trustmrr.com/startup/pinpoint",
  "category": "Mobile Apps",
  "country": "AE",
  "currency": "USD",
  "totalRevenueUsd": 1078.86,
  "last30DaysRevenueUsd": 548.83,
  "mrrUsd": 134.45,
  "activeSubscriptions": 26,
  "revenueGrowth30dPct": 121.16,
  "revenueLast7dUsd": 260,
  "monthlyRevenue": [{ "month": "2026-09", "revenueUsd": 295 }, { "month": "2026-10", "revenueUsd": 386 }],
  "paymentProvider": "revenuecat",
  "founderXHandle": "rahulnk",
  "appStoreName": "PinPoint: Peptide Tracker",
  "appStoreRating": 4.78,
  "onSale": true,
  "askingPriceUsd": 8000,
  "revenueMultiple": 1.21,
  "listingTierName": "Growth"
}
```

### Reliability

- Requests are paced per connection and spread across connections; temporary blocks switch to a fresh connection automatically, and long blocks pause briefly. Verification pages are never solved: the actor simply uses another connection.
- If something cannot be fetched, you get an explanatory error row that is **not charged**, and the run still finishes successfully.
- Runs survive platform migrations without duplicating or re-charging rows.
- If TrustMRR changes its page format, the actor refuses to guess and returns a `schema-changed` error row instead of empty data.

### Privacy

The actor returns only what TrustMRR publishes on public pages about startups and their founders (name, X handle, avatar, follower count, the founder's startups and verified revenue). It never returns e-mail addresses or phone numbers. You are responsible for using the data in line with applicable law (e.g. GDPR) and TrustMRR's terms.

### FAQ

**Does it need a TrustMRR account or API key?** No. It reads public pages only.

**How fresh is the data?** By default a startup or founder profile that any run fetched in the last 3 hours is reused from a shared cache (the row then carries `cachedAt`; it costs the same). TrustMRR itself syncs revenue with payment providers every few hours (median age 3.6 hours in our sample), and `revenueLastSyncedAt` tells you exactly when. Set `maxCacheAgeHours` to 0 to read every profile live.

**How many startups are there?** About 11,700 startups, 2,300 of them for sale (15 Oct 2026).

**How long does the whole catalog take?** All 11,703 startups took 61 minutes at 12 parallel requests (15 Oct 2026, every profile fetched live, one platform migration survived without duplicates). Set `maxItems` to 12000 and the run timeout to 2 hours. 100 startups take about 30 seconds.

**Why are some fields empty?** They are optional on TrustMRR (for example, only some founders connect GitHub or list a tech stack). Empty values are `null`, never invented.

# Actor input Schema

## `outputType` (type: `string`):

One row type per run. <b>startups</b>: full profile of every startup that matches your filters (about 80 filled fields per row: verified revenue for 7 periods, MRR, growth, last-30-day daily revenue, monthly revenue, founder, tech stack, channels, SEO, app store, sale listing). <b>startup-details</b>: the same full profile for the TrustMRR links or slugs you paste. <b>for-sale</b>: startups listed for sale, ranked like TrustMRR's "best deals", with asking price, multiple, price history, listing tier and seller message. <b>founders</b>: founder profiles with total revenue, MRR, followers, every startup and the monthly revenue since their first sale.

## `startupUrls` (type: `array`):

TrustMRR startup pages, for example https://trustmrr.com/startup/datafast, or just the slug (datafast). Only the slug is read from each entry. Pasting links with the type "Startups" switches the run to startup details; the filters below are not applied to pasted links. Entries that are not TrustMRR startup links get one error row that is not charged.

## `founders` (type: `array`):

X handles (marclou or @marclou), x.com profile links or TrustMRR founder links (https://trustmrr.com/founder/marclou). Empty = the founders of the top startups that match your filters below, in ranking order (country, price, multiple and payment-provider filters are checked on each startup profile first, at no charge). Pasting handles with the type "Startups" switches the run to founders.

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

Rows delivered (and charged) at most. Duplicates and error rows are never charged. The whole catalog is about 11,700 startups (2,300 for sale). When you paste startup links or founder handles and leave this empty, every one of them is delivered.

## `includeRevenueHistory` (type: `boolean`):

Adds revenueHistory: every day of verified revenue since tracking began (median 88 days, up to 5,000+ days, measured on 347 startups), with the number of charges per day. Charged as a separate event only when the startup has at least one day of history. Every row already includes the last 30 days and the monthly totals for free.

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

Only startups in any of these TrustMRR categories (matched by TrustMRR itself on the main category and the tags).

## `countries` (type: `array`):

Only startups based in these countries (the 121 countries with a TrustMRR country page). The country lists are ranked by total revenue, so with countries the order is always by revenue. About 1 in 5 startups has no country and never matches this filter.

## `onSaleOnly` (type: `boolean`):

Keep only startups listed for sale on the TrustMRR marketplace (about 2,300). Always on with outputType for-sale.

## `minMrr` (type: `integer`):

Monthly recurring revenue, verified by the payment provider.

## `maxMrr` (type: `integer`):

Monthly recurring revenue, verified by the payment provider.

## `minTotalRevenue` (type: `integer`):

All-time verified revenue.

## `maxTotalRevenue` (type: `integer`):

All-time verified revenue.

## `minGrowth30d` (type: `integer`):

For example 20 = revenue grew at least 20% versus the previous 30 days.

## `maxGrowth30d` (type: `integer`):

Negative values find startups that are shrinking.

## `minXFollowers` (type: `integer`):

Followers of the founder on X (Twitter).

## `targetAudience` (type: `string`):

B2B or B2C as declared on TrustMRR.

## `foundedYearMin` (type: `integer`):

For example 2025.

## `foundedYearMax` (type: `integer`):

For example 2020.

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

Only startups for sale with an asking price of at least this.

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

Only startups for sale with an asking price of at most this.

## `minMultiple` (type: `number`):

Asking price divided by annualized revenue, as TrustMRR computes it (e.g. 1.5).

## `maxMultiple` (type: `number`):

Asking price divided by annualized revenue (e.g. 2 = at most 2x).

## `paymentProviders` (type: `array`):

Only startups whose verified revenue comes from one of these providers (primary or secondary). Checked on each startup profile; startups that do not match are skipped without charge. Share of the catalog (11,701 startups, 15 Oct 2026): Stripe 56%, RevenueCat 15%, Dodo Payments 12%, Polar 8%, Lemon Squeezy 4%, every other provider under 3%. Each candidate is first checked on its small Markdown profile, so a run can check up to 100 startups per requested row (at least 1,000); providers under 2% (Creem, Whop, Superwall, Shopify, App Store) can still return fewer rows than Max rows.

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

Auto = total revenue for startups and founders, TrustMRR's "best deals" ranking for for-sale.

## `maxCacheAgeHours` (type: `integer`):

When a shared cache is available, a startup or founder profile fetched by any run in the last N hours is reused instead of being fetched again (TrustMRR syncs revenue every few hours: median age 3.6 h). Reused rows carry cachedAt and cost the same. 0 = always fetch live.

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

Requests in flight at once (each startup profile takes two requests). Higher values are faster on big runs; TrustMRR limits requests per connection, and the actor spreads them across connections on its own.

## Actor input object example

```json
{
  "outputType": "startups",
  "startupUrls": [],
  "founders": [],
  "maxItems": 20,
  "includeRevenueHistory": false,
  "categories": [],
  "countries": [],
  "onSaleOnly": false,
  "targetAudience": "any",
  "paymentProviders": [],
  "sortBy": "auto",
  "maxCacheAgeHours": 3,
  "maxConcurrency": 8
}
```

# Actor output Schema

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

The rows of this run: startup profiles, for-sale listings or founders, depending on the outputType you chose.

## `errors` (type: `string`):

Every error of the run with its reason and what to do. Always present, empty when nothing failed.

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

Counts of delivered, charged, duplicate, filtered and error rows for this run.

# 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": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("oswaldocarabano/trustmrr-startups-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 = { "maxItems": 20 }

# Run the Actor and wait for it to finish
run = client.actor("oswaldocarabano/trustmrr-startups-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 '{
  "maxItems": 20
}' |
apify call oswaldocarabano/trustmrr-startups-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,oswaldocarabano/trustmrr-startups-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/jqrjzOwqnWwz4EZ49/builds/AysW7e11o4OxtkxAj/openapi.json