# Dealroom.net Scraper - Companies, Startups & Market Maps (`abotapi/dealroom-co-scraper`) Actor

Scrape Dealroom.net market maps, company lookup results, live signals, and newly founded startup records. Supports Dealroom URLs, company names, market-map ids, sorting, capped runs, rich normalized company fields, and optional MCP connector export.

- **URL**: https://apify.com/abotapi/dealroom-co-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** E-commerce, SEO tools, Lead generation
- **Features:** Limited permissions
- **Stats:** 25 total users, 10 monthly users, 43.4% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 company intelligence records

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

## Dealroom Scraper: Startup, Funding and Market-Map Intelligence

Dealroom Scraper turns Dealroom into a clean startup and funding intelligence feed. Search public market maps, pull every company inside one, resolve company names to their Dealroom profile links, follow pasted Dealroom links, watch live funding signals, or track just-founded startups, all normalized into one company record shape with industries, funding, founders, locations and social links. Export to JSON, CSV or Excel, or pull the results straight into your app through the API.

### Why This Scraper?

- **Six ways to collect company data.** Search market maps by keyword, pull every company inside one, resolve company names, paste Dealroom links, watch live funding signals, or track just-founded startups. No need to build feed URLs by hand.
- **One normalized record shape.** Every mode returns the same company envelope: identity, market and product profile, growth and traction, funding, investors, locations, web and social presence, plus the complete public source object so nothing is lost.
- **Predictable, capped runs.** Max items defaults to a finite 20, so a first run never surprises you. Set it to 0 to remove the cap entirely.
- **Resume big pulls for free.** Paste a previous run or dataset id and the next run skips everything already collected there, so you never pay twice.
- **Built for schedules.** Incremental mode returns only new, updated and reappeared records on recurring runs, and a run that could not fully scan the tracked search skips expiry detection instead of guessing.
- **Optional connector export.** Pipe a summary of every saved record into Notion, Linear, Airtable or another Apify actor, as an extra step that never changes the dataset.
- **Drop-in compatible inputs.** A `limit` alias and a reserved `maxPages` field make it easy to swap in for a similarly shaped scraper without rewriting your integration.

### Use Cases

- **VC and startup scouts:** monitor Dealroom market maps for new entrants and funding signal changes in a sector.
- **Growth and competitive intelligence teams:** resolve named competitors to their Dealroom profile links, and pull market-map companies to track public funding and employee signals over time.
- **Newsletter and media teams:** pull just-founded startups and live funding signals to source story leads.
- **Data and research teams:** build a normalized company database from one or more market maps for internal analysis.
- **Sales and business development:** watch a target account list, by name or by URL, for material changes using incremental mode.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `type` | `"company"` (also `"marketmap"`, `"company_lookup"`, `"signal"` depending on mode) |
| `id` | `118442` |
| `url` | `"https://app.dealroom.co/companies/example-ai"` |
| `record_id` | `"example-ai"` |
| `company_name` | `"Example AI"` |
| `company_website` | `"https://example-ai.com"` |
| `company_identity.tagline` | `"AI infrastructure for enterprise teams"` |
| `company_identity.about` | `"Example AI builds developer tools for..."` (just-founded startups and market-map search rows; null in market-map companies, lookup and signal records) |
| `market_and_product_profile.industries` | `[{ "name": "Artificial Intelligence" }]` |
| `market_and_product_profile.tags` | `[{ "name": "Seed" }]` |
| `market_and_product_profile.lists` | `{ "items": [{ "title": "AI Startups 2025", "id": "53885" }], "total": 1 }` (market-map companies mode) |
| `growth_and_traction.employees` | `"11-50"` (market-map companies mode) |
| `funding_and_financials.total_funding_enhanced` | `{ "amount": 4200000, "currency": "USD" }` |
| `investors_and_ownership.founders` | `[{ "name": "Jane Doe" }]` |
| `locations_and_operations.hq_locations` | `[{ "city": "Berlin", "country": "Germany" }]` |
| `locations_and_operations.launch_year` | `2022` |
| `web_and_social_presence.linkedin_url` | `"https://linkedin.com/company/example-ai"` (just-founded startups only) |
| `news_and_signals.news_available` | `true` (lookup and company-URL results only, when "Include news metadata" is on and a news page exists; always `false` for other record types) |
| `news_and_signals.sentiment_available` | `false` |
| `source_record` | the untouched public source object for that row |
| `scrape_metadata.source_page_url` | `"https://app.dealroom.co/lists/53885"` |
| `scrape_metadata.seed_input_type` | `"marketmap"` |
| `scrapedAt` | `"2026-09-28T10:00:00.000Z"` |

A `marketmaps`-mode run returns type `"marketmap"` records instead: one row per public market map, with `company_name` holding the map's title, `url` its Dealroom charts link, `company_identity.about` and `tagline` both set to the map's description, and `market_and_product_profile.lists`/`lists_ids` pointing back at the map itself, while funding, employee and founder fields stay empty. A `lookup`-mode run returns type `"company_lookup"` records: an identity `path`/`name`/`url` match plus `news_and_signals.news_available`/`sentiment_available` flags; the profile fields (description, headquarters, founders, investors, valuation range, headcount, investments and patent families) are filled from the public company page when one is available and stay empty when the company has no public page. The lookup index itself carries no industry data. A `liveSignals`-mode run returns type `"signal"` records: `id` and `company_name` derived from the signal headline text since the feed has no upstream id, `company_identity.tagline` holding the short description, `locations_and_operations.hq_locations` with just a city, `funding_and_financials.total_funding_enhanced` holding the signal amount, and `news_and_signals.signal_type`/`signal_time` describing the event, with no website, industry or founder data.

**Company profile details.** For name-lookup rows (including pasted company links) the actor also reads the public Dealroom company page and fills the existing profile fields: description, logo, headquarters city and country, founding year, valuation range with the date last recorded, headcount range, employees mapped, founder names, investor names with the investor count, the number of active patent families (`investors_and_ownership.patents_count`, from the page's Dealroom / PatSnap patent estimate), and the company's own investments and M\&A. This adds no charge and no new field blocks. A company without a public page, or a page that cannot be read in a given run, leaves those fields empty for that run. Dealroom's public page shows ranges for valuation and headcount, and exact values stay behind Dealroom's own app. Shapes: `funding_and_financials.latest_valuation_enhanced` is `{ "range": "<valuation range as shown>", "last_recorded": "Mar/2026" }`; each `funding_and_financials.investments[]` entry is `{ "name", "sector", "year", "month", "kind", "stage", "amount", "currency" }` where `kind` is `Venture` or `M&A`, `stage` is the round name Dealroom shows (Seed, Series A, Series B, Series C+, Late, Other, M\&A), and `amount` is in whole US dollars (`currency` is `USD`; both are null when the deal amount is undisclosed), the same unit as `total_funding_enhanced.amount`. Profile pages are read on the connection that is already serving the other requests; a failing profile page never makes the run switch to a paid connection. In Incremental mode, runs saved before this addition do not flag every company as UPDATED once: for name-lookup records, fields that were empty and are now filled count as unchanged on the first run, and later changes are reported normally. A profile page that could not be read in a run is never reported as a change: the last profile data seen for that company is kept for comparison, so the record stays UNCHANGED (not returned and not billed unless Emit unchanged is on) and the run after a successful read is UNCHANGED too. Only name-lookup records carry this profile data; market-map, signal and other records are compared on everything they contain, with no migration.

### How to Use

1. Pick a **mode**: search market maps, pull every company in one market map, look up companies by name, paste Dealroom URLs, watch live funding signals, or track just-founded startups.
2. Fill in the fields for that mode: search query, market-map ids, company names, or start URLs.
3. Set **Max items** to control run size and cost, and switch news or sentiment enrichment on if you want those signals.
4. Click **Start**, then download the dataset as JSON, CSV or Excel, or read it through the API.

**Search market maps by keyword:**

```json
{
  "mode": "marketmaps",
  "searchQuery": "climate tech",
  "maxItems": 20
}
```

**Every company inside one market map, sorted by funding:**

```json
{
  "mode": "marketmap",
  "marketmapIds": ["landscape-53885"],
  "sortBy": "funding",
  "maxItems": 100
}
```

**Look up specific companies by name:**

```json
{
  "mode": "lookup",
  "companyNames": ["OpenAI", "Anthropic"],
  "includeNews": true,
  "includeSentiment": true
}
```

**Paste Dealroom links (company, list, landscape, or dealroom.co/api and /data feed links such as `api/marketmaps?q=AI`, `api/lookup-slug?name=OpenAI`, `api/live-signals`, `data/just-founded.json`; `app.dealroom.co/companies/f?q=OpenAI` runs a name lookup). Url mode with the field untouched scrapes a few rows from each of the 11 example links: with several links, each link gets a fair share of Max items (a link that returns less leaves its share to the next ones, and leftover rows fill any spare capacity), so one large market map cannot use up the whole cap. Other modes ignore this field:**

```json
{
  "mode": "urls",
  "startUrls": [
    "https://app.dealroom.co/lists/14655",
    "https://app.dealroom.co/companies/revolut"
  ],
  "maxItems": 10
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/dealroom-co-scraper").call(run_input={"mode": "marketmap", "marketmapIds": ["landscape-53885"]})
for company in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(company["company_name"], company["url"])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/dealroom-co-scraper').call({ mode: 'marketmap', marketmapIds: ['landscape-53885'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### Resume and recurring updates

- **Resume** (`resumeFromRunId`) continues one specific interrupted run: paste its run or dataset id and this run appends only records not already collected there, so you don't pay twice.
- **Incremental mode** (`incrementalMode`) is for scheduling the same search again and again. State is kept per mode, search, market-map ids, company names, sort order and enrichment toggles (raising Max items or adding a connector never starts a new baseline). Each record is classified `NEW`, `UPDATED` (with `changedFields`), `UNCHANGED` (suppressed and not billed unless `emitUnchanged` is on), `REAPPEARED`, or `EXPIRED`. `EXPIRED` is produced only after a run that proved a complete scan of the tracked search: no source was skipped, no source returned an unexpected shape, Max items did not cut the run short, and Resume was not used in the same run. `REAPPEARED` only occurs for a record an earlier run marked `EXPIRED`, so it requires Emit expired to have been on. `stateKey` names or shares the stored state; leaving it empty derives one automatically from the search settings. With Incremental mode off, output is exactly as before.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record, not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify, Settings, Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. If the picker is empty, you haven't authorized a connector yet.
3. For **Notion**, also set `notionParentPageUrl` to the page where records should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip. If a connector's data is not found or is not connected to your account, that connector is skipped with a warning and the dataset is unaffected.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `marketmaps` | Collection mode: search market maps, market-map companies, company name lookup, Dealroom URLs, live funding signals, or just-founded startups. |
| `startUrls` | array | 11 example URLs, one per supported shape, small feeds first | Dealroom company, list, landscape, market-map search, lookup, live-signals and just-founded feed URLs (`urls` mode only). If you choose `urls` mode and leave this field untouched, the run scrapes a few rows from each of the 11 links (each link gets a fair share of Max items). Company URLs resolve through the public lookup index; list and landscape URLs collect market-map companies. |
| `searchQuery` | string | none (prefill: `"AI"`) | Search term for public market-map discovery (`marketmaps` mode). |
| `marketmapIds` | array | `["landscape-53885"]` | Market-map ids or Dealroom list URLs (`marketmap` mode). |
| `companyNames` | array | `["OpenAI", "Anthropic"]` | Company names to resolve through the public lookup index (`lookup` mode). |
| `includeNews` | boolean | `true` | Adds the `news_available` flag to each saved record. The enrichment fee applies only to a record that actually gains a real signal, not merely for having this on. |
| `includeSentiment` | boolean | `true` | Adds the `sentiment_available` flag to each saved record. Same enrichment-fee rule as above. |
| `sortBy` | string | `source` | Sort saved rows: source order, company name A-Z, newest launch year first, or highest funding first. |
| `maxItems` | integer | `20` | Maximum rows to save. `0` removes the cap; the selected public source may still return fewer rows than requested. |
| `limit` | integer | none | Compatibility alias for competitor-style inputs. Only applies when Max items is left at its default of 20; an explicitly different Max items value always wins. |
| `maxPages` | integer | `0` (unused) | Reserved for competitor-input compatibility. Every mode fetches each target in a single request, so there is no page walk to bound. The run stops at Max items regardless of this field. |
| `pageSize` | integer | `50` | Page size requested from the source feed. Used only in `marketmaps` (search) and `liveSignals` mode. |
| `mcpConnectors` | array | none | Optional: send a summary of each saved record to apps you authorized under Integrations (Notion, Linear, Airtable, Apify). |
| `notionParentPageUrl` | string | none | Notion connector only: page under which records are created. |
| `maxNotifyListings` | integer | `50` | Cap on records written to each connector per run. Does not affect the dataset. |
| `proxyConfiguration` | object | Apify datacenter proxy, no groups | Requests are routed through the selected proxy. Datacenter is tried first; if Dealroom blocks it the run escalates to Apify Residential (billed by Apify to your account), then to a backup connection. Free plans have no residential access and run on the backup connection. A run that loads no page ends FAILED rather than empty. |
| `resumeFromRunId` | string | none | Continue one specific interrupted run: paste its run or dataset id and this run appends only records not already collected there. |
| `incrementalMode` | boolean | `false` | Turn on for recurring monitoring of the same search. Classifies each record NEW, UPDATED, UNCHANGED, REAPPEARED, or EXPIRED against saved state. |
| `stateKey` | string | none (auto-derived from mode/search/filter settings) | Name a monitoring campaign to keep its state stable, or to deliberately share state across differently configured runs. |
| `emitUnchanged` | boolean | `false` | Also return, and bill, records that have not changed since the last incremental-mode run. |
| `emitExpired` | boolean | `false` | Also return, and bill, records that were tracked before but are no longer found, marked EXPIRED. Only produced after a run that fully scanned the tracked search. |
| `ignoreFieldsForChanges` | string\[] | `[]` | Incremental mode only: field names or dotted paths (e.g. `growth_and_traction.employees`) that do not count as a change. The fields are still returned. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

```json
{
  "type": "company",
  "id": 118442,
  "url": "https://app.dealroom.co/companies/example-ai",
  "record_id": "example-ai",
  "company_name": "Example AI",
  "company_website": "https://example-ai.com",
  "scrape_metadata": {
    "source_page_url": "https://app.dealroom.co/lists/14655",
    "seed_identifier": "landscape-53885",
    "seed_input_type": "marketmap",
    "seed_input_value": "https://app.dealroom.co/lists/14655",
    "results_page_index": 1,
    "result_index": 4,
    "extraction_method": "public_feed",
    "scraped_time": 1780000000
  },
  "company_identity": {
    "name": "Example AI",
    "tagline": "AI infrastructure for enterprise teams",
    "about": null,
    "path": "example-ai",
    "website_url": "https://example-ai.com",
    "listing_page": "https://app.dealroom.co/companies/example-ai"
  },
  "market_and_product_profile": {
    "industries": [{ "name": "Artificial Intelligence" }],
    "tags": [{ "name": "Seed" }],
    "lists": { "items": [{ "title": "AI Startups 2025", "id": "53885", "type": "marketmap", "is_public": true }], "total": 1 },
    "lists_ids": ["53885"]
  },
  "growth_and_traction": {
    "employees": "11-50",
    "employees_latest": null,
    "traffic": { "visitors": null, "sources": [], "top_countries": [] }
  },
  "funding_and_financials": {
    "total_funding_enhanced": { "amount": 4200000, "currency": "USD" },
    "investments": [],
    "revenues": []
  },
  "investors_and_ownership": {
    "founders": [{ "name": "Jane Doe" }],
    "investors": { "items": [], "total": 0 }
  },
  "locations_and_operations": {
    "hq_locations": [{ "city": "Berlin", "country": "Germany" }],
    "launch_year": 2022,
    "growth_stage": null,
    "company_status": null
  },
  "web_and_social_presence": {
    "linkedin_url": null,
    "twitter_url": null,
    "facebook_url": null,
    "instagram_handle": null
  },
  "news_and_signals": {
    "news_available": false,
    "sentiment_available": false,
    "signal_type": null,
    "signal_time": null
  },
  "source_record": {
    "id": 118442,
    "name": "Example AI",
    "tagline": "AI infrastructure for enterprise teams"
  },
  "scrapedAt": "2026-09-28T10:00:00.000Z"
}
```

#### Output views

The dataset has three views in the Apify Console: **Dealroom records** (all modes, the company, market-map and lookup columns), **Changes (incremental mode)** (change status and changed fields), and **Live funding signals** (signal type, time and amount). Every view reads from the same dataset, so the full record is always available in JSON, CSV or Excel.

### Plan Requirement

Requests go through your selected proxy. The default is the Apify datacenter proxy; if Dealroom refuses it, the actor escalates to Apify Residential (billed by Apify to your account), then to a backup connection. Company profile pages are fetched best-effort on the connection already serving the data requests and never trigger the escalation above. Some Dealroom app pages (`app.dealroom.co`) show a browser challenge to plain connections, so the actor does not rely on a single connection type. Apify proxy access needs a paid Apify plan. On a free plan the run logs "Apify free plans do not include residential proxies. Continuing on a backup connection; some pages may still be unavailable." and, when a page is served that way, "Served over the backup connection (the default connection was unavailable)." Residential access is never forced: you can choose a proxy group or supply your own proxy URLs under Connection & proxy.

If no page can be loaded the run ends FAILED instead of returning an empty dataset, with one of these messages: "The proxy connection was refused for this account, so no page could be read. Your Apify plan does not include proxy access; a paid plan is required"; "No results: residential proxies are unavailable on this run (Apify free plans do not include them), and the backup connection could not load the requested Dealroom pages."; or "Could not load any results page (the requests failed), so nothing was collected. This is a connection problem, not an empty search." If you see these, upgrade your plan, supply your own proxy URLs, or re-run later.

### FAQ

#### How much does it cost?

Pay per event. The current rates and the lower paid-plan tiered rates are shown on the **Pricing** tab of this actor's page. The events and when each is charged:

| Event | When it is charged |
| --- | --- |
| Result (`apify-default-dataset-item`) | once for each record pushed to the dataset |
| Detail enrichment (`detail-enrichment`) | once per pushed record that gained a real news or sentiment signal; never merely because the toggle is on |
| Actor Start (`apify-actor-start`) | once per run |

Records suppressed in incremental mode (unchanged) are not billed. Use **Max items** to cap the cost of any run.

#### Is it legal to scrape Dealroom?

This actor collects only publicly available startup and funding information. You are responsible for how you use it: follow Dealroom's terms and the laws that apply to you, and get legal advice if you plan commercial redistribution. Company facts such as funding amounts and founding years are generally factual, but descriptions and other editorial content may be subject to third-party rights.

#### Can I get only new or changed companies on a schedule?

Yes. Schedule the actor from the **Schedules** tab and turn on **Incremental mode**. Each run then returns only NEW and UPDATED records (plus REAPPEARED if you also use Emit expired) for that saved search, and unchanged records are not returned or billed unless you turn on **Emit unchanged**.

#### Why did my run return no EXPIRED records even with Emit expired on?

EXPIRED records are only produced after a run that proved it scanned the entire tracked search: no source was skipped, no source returned an unexpected shape, Max items did not cut the run short, and Resume from a previous run was not used. If any of those happened, the run logs why expiry detection was skipped and leaves the previous state untouched so the next scheduled run can try again.

#### Why did my run fail instead of returning an empty dataset?

A run ends FAILED when no page could be loaded at all (see **Plan Requirement** for the three messages), when a Resume run id cannot be read by this Apify account, or when Incremental mode is combined with Resume on a state key that already has saved records (remove Resume, or use a different State key). A source Dealroom answers with "not found" (HTTP 404, for example a market-map id that does not exist) is not a failure: the run logs "No Dealroom record found for ...", still succeeds, and ends with the status message "No Dealroom record found for the requested source(s)" when nothing else was collected. If several sources in a row cannot be loaded on any connection, the run stops early with the connection message instead of retrying every remaining source. A single source that returns an unexpected shape is logged as a warning and the run still returns whatever else could be collected.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push a summary of results into Notion, Linear or Airtable.

### 🔗 Want more e-commerce data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>📇 <a href="https://apify.com/abotapi/betalist-com-scraper"><b>BetaList Scraper</b></a><br>Scrape BetaList.com startup profiles with founder and contact enrichment. Extract startup...</td><td>📇 <a href="https://apify.com/abotapi/ycombinator-com-scraper"><b>Ycombinator</b></a><br>Pull every ycombinator.com company across every batch, with founders, social URLs...</td></tr>
<tr><td>💼 <a href="https://apify.com/abotapi/f6s-directory-scraper"><b>F6S Scraper</b></a><br>Extract structured data from F6S.com. Scrape funding programs, startup accelerators...</td><td>📇 <a href="https://apify.com/abotapi/product-hunt-launches-scraper"><b>Product Hunt</b></a><br>Extract producthunt.com data including products, launches, keyword search results, maker...</td></tr>
<tr><td>🏷️ <a href="https://apify.com/abotapi/finn-no-jobs-scraper"><b>FINN.no Jobs Scraper</b></a><br>Scrape active FINN.no job listings by search filters or URL. Extract 30+ fields including...</td><td>🚗 <a href="https://apify.com/abotapi/craigslist-classifieds-scraper"><b>Craigslist Scraper</b></a><br>Scrape Craigslist postings in any of 700+ cities worldwide: price, title, posting text...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/dealroom-co-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

## `mode` (type: `string`):

Choose how to collect records. Precedence: the selected mode decides which inputs are used (Dealroom URLs apply to the URLs mode; search text, market map IDs and company names apply to the search, market map and lookup modes). Start URLs are only read when Mode is Dealroom URLs.

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

Dealroom company, list, landscape, API or data-feed URLs (used in Dealroom URLs mode; left untouched it scrapes a few rows of each of the 11 example shapes, each URL getting a fair share of Max items). Company URLs are resolved through Dealroom company indexes; list and landscape URLs collect market-map companies.

## `searchQuery` (type: `string`):

Search Dealroom market maps by title, description, tag, or keyword.

## `marketmapIds` (type: `array`):

Market-map ids or Dealroom list URLs, for example landscape-53885 or https://app.dealroom.co/lists/14655.

## `companyNames` (type: `array`):

Company names to resolve in Dealroom public indexes.

## `includeNews` (type: `boolean`):

Add the news_available signal to each saved record. When on, the detail-enrichment fee applies per saved record; turn it off to drop the field and the fee.

## `includeSentiment` (type: `boolean`):

Add the sentiment_available signal to each saved record. When on, the detail-enrichment fee applies per saved record; turn it off to drop the field and the fee.

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

Sort saved rows after collection.

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

Maximum rows to save. Set 0 for unlimited; the selected public source may return fewer rows than requested.

## `limit` (type: `integer`):

Compatibility alias for competitor inputs. Max items takes precedence when both are set.

## `maxPages` (type: `integer`):

Unused reservation field kept for competitor-input compatibility; every mode fetches each target in a single request, so there is no page walk to bound. Leave empty. The run stops at Max items.

## `pageSize` (type: `integer`):

Page size for market-map search and signal modes.

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

Requests go through the selected proxy. Datacenter is tried first; if Dealroom blocks it, the run automatically moves to a residential connection (residential traffic is billed by Apify to your account; free plans have no residential access and run on a backup connection instead).

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large pull without returning or charging for records already collected there. Use this after an interrupted run. For recurring monitoring of the same search, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns all matching records as NEW. Later runs normally return only NEW, UPDATED, and REAPPEARED records. Turn on "Emit unchanged" or "Emit expired" only when you also want those records returned (and billed). State is kept separately per mode/search/filters/toggle setup; use State key to name or deliberately share a monitoring campaign. To continue one specific interrupted run instead, use Resume from a previous run above.

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently-configured runs. Leave empty to let the actor derive a key automatically from the mode/search/filter/toggle settings — different searches then never mix state with each other.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return records that have not changed since the last run, marked UNCHANGED. This returns — and bills — extra rows you already have, so leave it off unless you specifically want the full snapshot every run.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return records that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search — not when Max items capped it, a source was skipped, or Resume was used. This returns — and bills — extra synthetic rows, so leave it off unless you need expiry tracking.

## `ignoreFieldsForChanges` (type: `array`):

Field names (or dotted paths such as growth_and_traction.employees) that should NOT count as a change in incremental mode. A record whose only differences are in these fields stays UNCHANGED. The fields are still returned in the output. Leave empty to compare every field.

## `mcpConnectors` (type: `array`):

Optionally send a concise copy of each record into apps via MCP connectors. The full JSON stays in the dataset. Supported: Notion, Linear, Airtable, Apify.

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which records should be created. Required only for Notion connector export.

## `maxNotifyListings` (type: `integer`):

Cap on records written to each connector. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "marketmaps",
  "startUrls": [
    "https://dealroom.co/api/lookup-slug?name=OpenAI&type=company&limit=3",
    "https://dealroom.co/companies/stripe",
    "https://app.dealroom.co/companies/f?q=Mistral",
    "https://dealroom.co/api/live-signals?limit=3",
    "https://dealroom.co/api/marketmaps?q=AI&limit=3",
    "https://dealroom.co/api/marketmaps?tag=fintech&limit=3",
    "https://dealroom.co/data/just-founded.json",
    "https://app.dealroom.co/companies/revolut",
    "https://app.dealroom.co/lists/14655",
    "https://dealroom.co/charts/landscape-52820-ai-x-climate-tech.html",
    "https://dealroom.co/api/marketmap?id=landscape-53885"
  ],
  "searchQuery": "AI",
  "marketmapIds": [
    "landscape-53885"
  ],
  "companyNames": [
    "OpenAI",
    "Anthropic"
  ],
  "includeNews": true,
  "includeSentiment": true,
  "sortBy": "source",
  "maxItems": 20,
  "pageSize": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `changes` (type: `string`):

No description

## `signals` (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 = {
    "startUrls": [
        "https://dealroom.co/api/lookup-slug?name=OpenAI&type=company&limit=3",
        "https://dealroom.co/companies/stripe",
        "https://app.dealroom.co/companies/f?q=Mistral",
        "https://dealroom.co/api/live-signals?limit=3",
        "https://dealroom.co/api/marketmaps?q=AI&limit=3",
        "https://dealroom.co/api/marketmaps?tag=fintech&limit=3",
        "https://dealroom.co/data/just-founded.json",
        "https://app.dealroom.co/companies/revolut",
        "https://app.dealroom.co/lists/14655",
        "https://dealroom.co/charts/landscape-52820-ai-x-climate-tech.html",
        "https://dealroom.co/api/marketmap?id=landscape-53885"
    ],
    "searchQuery": "AI",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    },
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/dealroom-co-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": [
        "https://dealroom.co/api/lookup-slug?name=OpenAI&type=company&limit=3",
        "https://dealroom.co/companies/stripe",
        "https://app.dealroom.co/companies/f?q=Mistral",
        "https://dealroom.co/api/live-signals?limit=3",
        "https://dealroom.co/api/marketmaps?q=AI&limit=3",
        "https://dealroom.co/api/marketmaps?tag=fintech&limit=3",
        "https://dealroom.co/data/just-founded.json",
        "https://app.dealroom.co/companies/revolut",
        "https://app.dealroom.co/lists/14655",
        "https://dealroom.co/charts/landscape-52820-ai-x-climate-tech.html",
        "https://dealroom.co/api/marketmap?id=landscape-53885",
    ],
    "searchQuery": "AI",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/dealroom-co-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": [
    "https://dealroom.co/api/lookup-slug?name=OpenAI&type=company&limit=3",
    "https://dealroom.co/companies/stripe",
    "https://app.dealroom.co/companies/f?q=Mistral",
    "https://dealroom.co/api/live-signals?limit=3",
    "https://dealroom.co/api/marketmaps?q=AI&limit=3",
    "https://dealroom.co/api/marketmaps?tag=fintech&limit=3",
    "https://dealroom.co/data/just-founded.json",
    "https://app.dealroom.co/companies/revolut",
    "https://app.dealroom.co/lists/14655",
    "https://dealroom.co/charts/landscape-52820-ai-x-climate-tech.html",
    "https://dealroom.co/api/marketmap?id=landscape-53885"
  ],
  "searchQuery": "AI",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false
}' |
apify call abotapi/dealroom-co-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/dealroom-co-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/G5yBssQZD6Xlf6XMl/builds/c0243Z3vRpHMyUp72/openapi.json