# TrustMRR Startups Scraper - Revenue & Sale Data (`benthepythondev/trustmrr-startups-scraper`) Actor

Scrape public TrustMRR startup cards with name, category, revenue, sale price, valuation multiple, status and profile URL.

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

## Pricing

from $4.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

## TrustMRR Startups Scraper - Revenue & Sale Data

Turn public source pages into structured, analysis-ready data with **TrustMRR Startups Scraper - Revenue & Sale Data**. The Actor is designed for SaaS research, founder benchmarking, startup acquisition monitoring, valuation comparisons, and market maps. It runs in Apify, writes one record per result to the default dataset, and supports JSON, CSV, Excel, XML, RSS, API access, schedules, webhooks, Make, Zapier, and n8n.

The current engine reads TrustMRR's server-rendered public startup cards. It does not require a user login or a private API key. Defaults are intentionally small so a first run is fast, inexpensive, and suitable for Apify's automated health checks.

### What this Actor does

- Collects current public records from the selected source
- Accepts focused keywords or source search URLs
- Returns normalized fields while retaining source wording
- Removes duplicate records within a run
- Caps results with `maxResults` for predictable cost
- Raises an explicit error when the source unexpectedly returns no data
- Supports recurring monitoring through Apify schedules

### Data extracted

- `name` - source-provided name value.
- `category` - source-provided category value.
- `for_sale` - source-provided for sale value.
- `revenue` - source-provided revenue value.
- `revenue_text` - source-provided revenue text value.
- `price` - source-provided price value.
- `price_text` - source-provided price text value.
- `multiple` - source-provided multiple value.
- `multiple_text` - source-provided multiple text value.
- `url` - source-provided url value.

Every record also contains source context and a scrape timestamp where relevant. Missing values remain null rather than being guessed. This distinction matters for research: an undisclosed salary, price, fee, or location is not the same as zero.

### Input

The input editor provides a tested default and prefill. Keep the first run at ten results, inspect the dataset, then increase the limit only for searches that produce useful records.

```json
{"searchUrls":["https://trustmrr.com/"],"maxResults":10}
````

`maxResults` applies per keyword or input URL. The Actor enforces a hard upper bound to prevent accidental unbounded runs.

### Example output

```json
{"name":"Ritual75","category":"Health & Fitness","revenue":534,"price":7000,"multiple":1.1,"source":"TrustMRR Startups"}
```

The example shows the output shape from a live source probe. Public listings change continuously, so names, dates, amounts, and availability in future runs will differ.

### Common workflows

#### Scheduled monitoring

Save the input as an Apify task and run it daily or weekly. Store the source ID or canonical URL as the durable key, compare the newest dataset with the previous one, and send only newly observed records to Slack, email, Telegram, a spreadsheet, or a data warehouse.

#### Market and competitor research

Normalize categories, companies, locations, and numeric fields outside the Actor while retaining the source text. This produces an auditable dataset for trend analysis without pretending that every source uses the same definitions.

#### Lead and account research

Use a public listing as a research signal, not as automatic permission for outreach. Enrich only records that fit a documented business purpose, keep the source URL beside the enrichment, and apply a human review before contact.

#### Dataset and API delivery

Download the default dataset in JSON, CSV, or Excel, or call the dataset API from your application. Apify integrations can forward completed-run data to Make, Zapier, n8n, Google Sheets, cloud storage, or a webhook.

### Pricing

The Actor uses transparent pay-per-event pricing: a small `$0.00005` start event and **$0.004 per startup** saved to the default dataset. This price is positioned against current public competitors while preserving room for maintenance. The input result limit gives direct control over spend.

### Reliability and data quality

The engine retries temporary request failures, uses a browser-like user agent where needed, deduplicates source identifiers, and fails visibly when no records are found. A successful process with an empty dataset is not treated as healthy.

Source websites can change markup or embedded data. If a field suddenly becomes empty, open an Actor issue with the run ID and a public input. Do not include passwords, private cookies, account sessions, or confidential data. Small reproducible inputs make support faster.

For production use, monitor the run status, result count, and presence of key fields. Alert on a sharp row-count drop as well as a failed run. Keep historical snapshots when changes over time matter; do not overwrite previous values and then treat the latest state as historical fact.

### Responsible use

Use the Actor only for lawful collection and processing of public data. Respect source terms, robots and rate expectations, copyright, database rights, and applicable privacy, employment, marketing, and consumer-protection rules. Do not use it to evade authentication, collect private records, harass people, or send indiscriminate messages.

Collect only fields needed for the stated workflow, define a retention period, protect exported datasets, and honor deletion or opt-out obligations that apply to your use case.

### FAQ

**Do I need an account on the source website?**\
No. The Actor uses the public data path documented above.

**Can I run it on a schedule?**\
Yes. Save an input as a task and attach an Apify schedule.

**How do I avoid duplicates?**\
Use the source ID when present and the canonical URL as a fallback key. The Actor also deduplicates within each run.

**Why is a field null?**\
The source did not expose that field in the collected record. The Actor does not fabricate missing values.

**Can I export to a spreadsheet?**\
Yes. Download CSV or Excel directly, or connect the dataset to Make, Zapier, n8n, or Google Sheets.

**How should I report a problem?**\
Open the Actor's Issues tab with a run ID, public input, expected field, and observed result. Never attach private credentials.

### Support and feedback

If this Actor saves time in your workflow, please leave a short Apify Store review. Reviews help other users evaluate the tool and help prioritize maintenance. For a source change, submit a reproducible issue instead of silently retrying a large run.

### You might also like

- [Remote Jobs Aggregator](https://apify.com/benthepythondev/remote-jobs-aggregator) for multi-source job monitoring
- [Website Contact Extractor](https://apify.com/benthepythondev/website-contact-extractor) for public business-contact enrichment
- [Y Combinator Companies Scraper](https://apify.com/benthepythondev/y-combinator-companies-scraper) for startup and company research

***

**Keywords:** trustmrr scraper - startup revenue, price & mrr multiples, public data API, dataset export, monitoring automation, structured data, CSV export, JSON API, Apify Actor, scheduled scraper, market research.

# Actor input Schema

## `searchUrls` (type: `array`):

TrustMRR directory or filtered URLs to collect.

## `maxResults` (type: `integer`):

Maximum unique startup cards returned per input URL.

## Actor input object example

```json
{
  "searchUrls": [
    "https://trustmrr.com/"
  ],
  "maxResults": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchUrls": [
        "https://trustmrr.com/"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/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 = {
    "searchUrls": ["https://trustmrr.com/"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/trustmrr-startups-scraper").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 '{
  "searchUrls": [
    "https://trustmrr.com/"
  ],
  "maxResults": 10
}' |
apify call benthepythondev/trustmrr-startups-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=benthepythondev/trustmrr-startups-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TrustMRR Startups Scraper - Revenue & Sale Data",
        "description": "Scrape public TrustMRR startup cards with name, category, revenue, sale price, valuation multiple, status and profile URL.",
        "version": "1.0",
        "x-build-id": "38Im4M7ZTlFa3htDd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~trustmrr-startups-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-trustmrr-startups-scraper",
                "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/benthepythondev~trustmrr-startups-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-trustmrr-startups-scraper",
                "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/benthepythondev~trustmrr-startups-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-trustmrr-startups-scraper",
                "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": {
                    "searchUrls": {
                        "title": "TrustMRR URLs",
                        "type": "array",
                        "description": "TrustMRR directory or filtered URLs to collect.",
                        "default": [
                            "https://trustmrr.com/"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum startups per URL",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum unique startup cards returned per input URL.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```