# Built In Startup Scraper — Tech Stack, Industries, HQ (`foxlabs/builtin-intelligence`) Actor

Scrape startup company profiles from BuiltIn.com — tech stack, industries, headquarters, employee count, founded year, perks and the open jobs shown on each profile. Pick a sector preset (SaaS, Fintech, AI/ML, eCommerce, Gaming, Crypto) or paste company names or Built In URLs.

- **URL**: https://apify.com/foxlabs/builtin-intelligence.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Business, Lead generation
- **Features:** Limited permissions
- **Stats:** 12 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 company records

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?

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

## Built In Startup Scraper — Tech Stack, Industries, HQ 💻

**foXLabs company-intelligence series:** [Company enrichment](https://apify.com/foxlabs/company-enrichment) · [Owler](https://apify.com/foxlabs/owler-intelligence) · [Craft](https://apify.com/foxlabs/craft-intelligence) · [Free lookup](https://apify.com/foxlabs/company-lookup-free)

🎉 Turn Built In company profiles into structured JSON — industries, tech stack, HQ, founded year, employee count, description, benefit categories and the number of jobs shown on the profile, one row per company.
Built for tech-sector prospecting, recruiting research and technology targeting.

### 🔍 What is Built In Startup Scraper — and when should you use it?

Give this Actor **company names** or **Built In URLs** — or pick a **sector preset** — and it returns one record per company from the public company profiles on [Built In](https://builtin.com), a directory of tech companies and startups. A preset starts from a list of anchor companies and can also page through the sector's Built In directory to find more. Every run reads the pages live.

**Use it when you need:** a prospect list of tech companies with HQ, size and industries; the technologies a company shows on its Built In profile; a sector sweep (SaaS, fintech, AI/ML, eCommerce, gaming, crypto) from Built In's directory.

**Use something else when:** a company has no Built In profile (its name then returns an `HTTP 404` error row), or you need revenue, funding or competitors — [Owler Scraper](https://apify.com/foxlabs/owler-intelligence) returns those.

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/builtin-intelligence`.

**Your agent can pay for its own runs.** This Actor is pay-per-event with agentic payments, so an agent can discover it, run it and settle the bill over **x402 (USDC on Base)** or **Skyfire** — no Apify account or API token of its own. Billing is the same either way: per delivered company record — rows that only report a failed lookup are free from 25 September 2026.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
I want tech-company profiles from the Apify Actor `foxlabs/builtin-intelligence`.
Input: `companyNames` is a list of company names, each turned into a Built In URL (lowercased, spaces replaced by hyphens — no search); `companyUrls` takes exact Built In company URLs; or set `preset` to a sector (saas, fintech, ai-ml, ecommerce, gaming, crypto-web3), where `presetDepth` 0 keeps to its anchor companies and 1 or more also reads the sector's Built In directory. `maxResults` caps the rows.
Start with: {"companyNames":["Notion","Datadog","Asana"],"maxResults":100}
Ask me what to look up, run the Actor, then summarise the rows as a table.
```

The machine-readable API, MCP config and OpenAPI definition live at `apify.com/foxlabs/builtin-intelligence.md`.

### 📋 Overview

Everything you need to turn Built In profiles into structured data — in one Actor, with no login, cookies or API key.

**Why teams pick this Actor:**

- ✅ **Names, URLs or a sector preset** — names become Built In URLs directly; presets start from 12–23 anchor companies per sector.
- 🛠️ **Tech stack** — the technologies shown on the company's Built In profile (52 for Asana and 73 for Datadog in our test run).
- 🏢 **Firmographics** — HQ city, state, country and postal code, founded year, employee count, industry tags.
- 🧭 **Directory discovery** — with a preset, the sector's Built In directory pages are read to find companies beyond the anchors.
- 💰 **Pay per record** — $0.004 per company record, no subscription.
- 🤖 **Agent-ready** — MCP + x402 agentic payments.

### ✨ Features

- 🔍 **Three ways in** — `companyNames`, `companyUrls` (Built In company URLs or a .txt / .csv upload) and `preset`; they can be combined.
- 🧭 **Six sector presets** — anchor companies plus, with `presetDepth` 1–4, the companies listed on the sector's Built In directory pages (e.g. `builtin.com/companies/type/fintech`), kept when they match the sector's keywords.
- 🧾 **List and text versions** — `industries` / `industriesText` and `techStack` / `techStackText`, ready for CSV.
- 🚦 **Misses are visible** — a name or URL without a Built In page comes back as a row with `error: HTTP 404`.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~builtin-intelligence/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companyNames":["Notion","Datadog","Asana"],"maxResults":100}'
```

### 🚀 Getting Started (3 steps)

1. **Choose companies** — type names (they become Built In URLs), paste Built In URLs, or pick a sector preset.
2. **Set the cap** — `maxResults` limits the companies saved (default 100; 0 = no limit).
3. **Run and export** — download the dataset as JSON, CSV, Excel, HTML or XML.

### 📥 Input

```json
{"companyNames":["Notion","Datadog","Asana"],"maxResults":100}
```

| Field | Type | Description |
|---|---|---|
| `preset` | string | Start from a sector's anchor companies: `saas` (23), `fintech` (15), `ai-ml` (13), `ecommerce` (15), `gaming` (12), `crypto-web3` (13). Combined with names and URLs when both are given. |
| `presetDepth` | integer | Preset only. 0 = only the anchor companies; 1–4 = also read the sector's Built In directory pages and add the companies listed there whose industries, tagline, description or HQ match the sector's keywords (every value from 1 to 4 behaves the same). Default 2. |
| `companyNames` | array | Company names, one per line. Each becomes `https://builtin.com/company/<name>` — lowercased, spaces replaced by hyphens, no search. A name without a Built In page returns an `error: HTTP 404` row. |
| `companyUrls` | array | Built In company URLs (`https://builtin.com/company/<slug>`), or a .txt / .csv upload. URLs from other sites are ignored. |
| `maxResults` | integer | Cap on companies saved (default 100; 0 = no limit). Without a preset only the first `maxResults` companies are fetched; with a preset, pages already in progress still finish, so the count can end slightly above the cap. |
| `maxConcurrency` | integer | Pages fetched in parallel (default 10, max 50). |
| `maxListingPages` | integer | Discovery only — pages of each sector directory to read (default 30, max 100). Also limited to ⌈maxResults ÷ 18⌉ + 1 pages, and to 30 pages when `maxResults` is 0. |
| `proxyConfiguration` | object | Apify proxy settings (default: Apify proxy, automatic selection). |

**More recipes**

- Sector anchors only: `{"preset":"fintech","presetDepth":0,"maxResults":2}` — returned Stripe and Plaid (the first two fintech anchors) in our test run.
- Names without a Built In page stay visible: `{"companyNames":["Notion","zzqx-no-such-company-2026"]}` — Notion plus a row with `error: HTTP 404`.

### 📤 Output

One row per company. A name or URL without a Built In page comes back as a row with only `url`, `error` (e.g. `HTTP 404`) and `scrapedAt`; so does a page on which no company name was found, or one that could not be read. A page that still fails after its retries — blocked or server errors — is only logged, not written. From 25 September 2026 rows with `error` are not charged.

| Field | Description |
|---|---|
| `url` / `slug` | Built In profile URL and its slug |
| `name` | Company name |
| `description` | The company's own description from Built In's structured company data (not the page's SEO text) |
| `tagline` | The one-line pitch under the industry tags; `null` when the profile has none |
| `logo` / `website` | Logo image URL and company website |
| `headquarters` | HQ as `City, State, Country` |
| `headquartersCity` / `headquartersState` / `headquartersCountry` / `headquartersPostalCode` | HQ in parts |
| `yearFounded` | Founding year |
| `employees` | Employee count Built In publishes for the company |
| `industries` / `industriesText` | Built In industry tags, as a list and comma-joined |
| `techStack` / `techStackText` | Technologies shown on the profile, as a list and comma-joined; empty when the profile shows none |
| `perks` | The benefit categories shown on the profile (e.g. `Healthcare Benefits`) — category headings, not individual benefits |
| `openPositions` | Job cards on the profile page — not the company's total number of openings (see FAQ); 0 when the profile shows none |
| `scrapedAt` | Timestamp of the scrape |
| `error` | Miss rows only — why the page could not be read |

In our test runs (Asana, Datadog, Notion, Plaid, Stripe) every field was filled for all five companies except `tagline` and `techStack` / `techStackText` (3 of 5 each; Plaid and Stripe had neither).

Sample — Notion, from our test run on 2026-09-10 (lists trimmed to their first three entries):

```json
{
  "url": "https://builtin.com/company/notion",
  "slug": "notion",
  "name": "Notion",
  "description": "Notion is a collaborative AI workspace. Teams use it to store knowledge, run projects, take meeting notes, and build AI workflows — all in one place, so AI always has the context it needs to be useful. We're building the layer where AI stops being a chat window and starts being part of how work gets done. Knowledge, decisions, and action in one connected system.",
  "tagline": "Notion is the AI workspace where teams and AI think together. Come build work that lasts.",
  "logo": "https://builtin.com/sites/www.builtin.com/files/2021-12/notion logo.jpeg",
  "website": "https://www.notion.so/product",
  "headquarters": "San Francisco, CA, US",
  "headquartersCity": "San Francisco",
  "headquartersState": "CA",
  "headquartersCountry": "US",
  "headquartersPostalCode": "94105",
  "yearFounded": 2016,
  "employees": 1000,
  "industries": [
    "Artificial Intelligence",
    "Productivity",
    "Software"
  ],
  "industriesText": "Artificial Intelligence, Productivity, Software",
  "techStack": [
    "Go",
    "JavaScript",
    "MySQL"
  ],
  "techStackText": "Go, JavaScript, MySQL, Perl, Python, Scala, Snowflake, SQL, TypeScript, Figma, Tableau, Salesforce, Slack, Zoom",
  "perks": [
    "Compensation + Total Rewards",
    "Diversity, Equity + Inclusion",
    "Employee Satisfaction + Recognition"
  ],
  "openPositions": 9,
  "scrapedAt": "2026-09-10T14:52:38.189Z"
}
```

### 💼 Use cases

**1. Tech-sector prospecting** — a target list without having a list.
*Input:* a sector preset. *Output:* companies with industries, HQ, employee count and website. *Use:* a prospect list for outreach.

**2. Recruiting and employer research** — what a tech employer shows on Built In.
*Input:* company names. *Output:* description, tagline, benefit categories, jobs shown on the profile, HQ. *Use:* brief candidates or clients.

**3. Technology targeting** — who shows a given technology.
*Input:* a list of companies. *Output:* `techStack`. *Use:* filter for companies that show, say, Snowflake.

### 🔗 Integration

**JavaScript / Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/builtin-intelligence').call({"companyNames":["Notion","Datadog","Asana"],"maxResults":100});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/builtin-intelligence').call(run_input={"companyNames": ["Notion", "Datadog", "Asana"], "maxResults": 100})
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)
```

Written for `apify-client` 3 for Python, where `call()` returns a run object; with version 1 or 2 it returns a dict — write `run['defaultDatasetId']` there.

**Automation (n8n / Zapier / Make):** schedule or webhook → HTTP request to the Actor API with your `companyNames` or `preset` → handle the JSON dataset → push to a sheet, CRM or dashboard.

### 📊 Pricing

Pay-per-event: **$0.004 per delivered company record** (≈ $4 per 1,000 companies), plus Apify's run-start event ($0.00005 per GB of run memory). With a preset, pages already in progress when `maxResults` is reached still finish, so a preset run can save — and charge for — slightly more companies than `maxResults`. **From 25 September 2026, rows that only report a failed lookup (`error`) are free.** Until then Apify still counts them as dataset items. [Current pricing](https://apify.com/foxlabs/builtin-intelligence).

### ❓ FAQ

**Where does the data come from?** From Built In's public company profile pages (`builtin.com/company/…`): the structured company data embedded in each page plus the page itself. Presets with discovery also read Built In's sector directory pages (`builtin.com/companies/type/…`). No login is needed.

**How are names matched?** Without search: the name is lowercased and spaces become hyphens (`Notion` → `builtin.com/company/notion`). If a company's Built In address differs, paste its URL; check `name` and `website` in the output to confirm the page is the company you meant.

**What does `openPositions` count?** The job cards on the company's profile page — 9 for Datadog, Notion and Stripe and 0 for Asana and Plaid in our test runs. On Datadog's profile the full list sits behind "View all jobs", so the number is not the company's total openings.

**What are `perks`?** The benefit categories shown on the profile (for example `Healthcare Benefits`) — category headings, not individual benefits. Datadog and Notion had the same six categories in our test.

**Can I export to CSV / Excel / JSON?** Yes — directly from the Apify dataset.

### 🐛 Troubleshooting

- **A name returns `error: HTTP 404`** — the company's Built In address differs from its name, or it has no profile; find it on builtin.com and paste the URL.
- **The run fails with "No companies to scrape"** — no names, no Built In URLs and no preset were given.
- **`techStack` is empty** — the profile shows no technologies (Stripe and Plaid in our test).
- **A preset run returns fewer companies than expected** — `presetDepth` 0 gives only the anchors; discovered companies are filtered by the sector's keywords, and `maxListingPages` and `maxResults` limit the directory pages read.

### ⚖️ Is it legal to scrape this data?

The Actor reads publicly accessible company profile pages and returns company information only — no personal profiles. Check that your use fits the source website's terms. Built In is a trademark of its owner; this Actor is not affiliated with Built In.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🐛 **Issues:** open a ticket in the Actor’s **Issues** tab
- 🧰 **More clean B2B data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.1.31 — 2026-10-08 — README: the Python example works with the current Apify client

- The README's Python example read the results with `run['defaultDatasetId']`. With the current Apify client for Python (version 3) `call()` returns a run object, not a dict, and that line raised `TypeError: 'Run' object is not subscriptable` — after the run itself had finished. The example now reads `run.default_dataset_id`; with client version 1 or 2, keep `run['defaultDatasetId']`. Checked with apify-client 3.2.1, 2.5.1 and 1.12.2.
- No code, output field or pricing change.

#### 0.1.29 — 2026-09-10 — failed lookups become free (per-record billing) + README corrected

- **You will pay only for delivered company records.** The Actor now charges a new `company-record` event for each delivered company, and rows that only report a failed lookup (`error`) are pushed without a charge.
- **Timing:** Apify applies pricing changes after a 14-day notice. From **25 September 2026** the pricing switches from the per-dataset-item event to `company-record` at the same price ($0.004). Until then billing is exactly as before; the code detects the switch by itself.
- No output field changed.
- **README corrected.** The 2026-09-07 README documented inputs this Actor does not have (`queries`, `maxResultsPerQuery`, `includeRaw`) with a placeholder (`undefined`) example, promised name search and registry-ID lookup (names are turned into Built In URLs; there is no search), called `employees` a registered count, and promised status / legal form / formation date, "formation / status monitoring", "whole dataset in one call", "every row carries `query`" and "empty/failed lookups never billed"; it also left out the sector presets and `maxListingPages`. This README describes the real inputs, output and billing.

#### 0.1 — 2026-09-07

- AI-agent payments (x402) enabled and the README replaced with a generated template; that README described inputs this Actor does not have and was replaced in 0.1.29.

#### 0.0

- Initial release.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/builtin-intelligence/changelog.md

# Actor input Schema

## `preset` (type: `string`):

Pick a sector — we seed curated anchor companies PLUS Built In's live industry directory (e.g. /companies/type/artificial-intelligence) and scrape every company found, filtered to the sector. Every run is live (today's directory, not a frozen list). Use `Discovery` to turn directory expansion on/off and `Maximum companies` to cap scope.

## `presetDepth` (type: `integer`):

0 = scrape only the curated anchor companies. 1+ = ALSO discover companies from the sector's Built In directory pages (hundreds per sector), filtered to the sector. 'Maximum companies' is always the hard cap.

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

Type Built In company names — one per line (e.g. `Notion`, `Datadog`). Each resolves to its Built In page (name lowercased + hyphenated). ⚠ A shared/ambiguous name can land on the wrong company (e.g. `monday` is a different company on Built In, not monday.com) — paste the exact URL below when in doubt.

## `companyUrls` (type: `array`):

Use this for exact URLs or to upload a .txt/.csv of many companies, e.g. `https://builtin.com/company/notion`.

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

Hard cap on results — pay-per-result pricing scales linearly. Set 0 for unlimited.
• 100 ≈ $0.40
• 1,000 ≈ $4
• 10,000 ≈ $40

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

How many company pages to fetch in parallel. Default `10` is balanced; push 20-30 for bulk runs.

## `maxListingPages` (type: `integer`):

In preset + Discovery mode, how many pages of each Built In sector directory to page through for company discovery. Only used when a preset is chosen with Discovery on; it is also auto-capped by 'Maximum companies'. Leave at 30 for most runs.

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

Apify Datacenter proxy is sufficient for Built In.

## Actor input object example

```json
{
  "preset": "",
  "presetDepth": 2,
  "companyNames": [
    "Notion",
    "Datadog",
    "Asana"
  ],
  "companyUrls": [],
  "maxResults": 100,
  "maxConcurrency": 10,
  "maxListingPages": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "presetDepth": 2,
    "companyNames": [
        "Notion",
        "Datadog",
        "Asana"
    ],
    "companyUrls": [],
    "maxResults": 100,
    "maxConcurrency": 10,
    "maxListingPages": 30,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/builtin-intelligence").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 = {
    "presetDepth": 2,
    "companyNames": [
        "Notion",
        "Datadog",
        "Asana",
    ],
    "companyUrls": [],
    "maxResults": 100,
    "maxConcurrency": 10,
    "maxListingPages": 30,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/builtin-intelligence").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 '{
  "presetDepth": 2,
  "companyNames": [
    "Notion",
    "Datadog",
    "Asana"
  ],
  "companyUrls": [],
  "maxResults": 100,
  "maxConcurrency": 10,
  "maxListingPages": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call foxlabs/builtin-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,foxlabs/builtin-intelligence"
        }
    }
}
```

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/y0dhNe89f14CCUSaa/builds/YIpqK4U0FXwpZ7jhm/openapi.json