# BuiltIn Tech Company Directory & Hiring Signal Scraper (`nimbryxo-studio/builtin-tech-company-directory-and-hiring-signal`) Actor

Browse BuiltIn.com's tech company directory by US city and office type, or look up specific companies by name, for employee count, industries, benefits, hiring status and open-jobs count.

- **URL**: https://apify.com/nimbryxo-studio/builtin-tech-company-directory-and-hiring-signal.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## BuiltIn Tech Company Directory & Hiring Signal Scraper

BuiltIn runs city-specific tech-company directories — builtinchicago.com, builtinboston.com, and more — each listing employers with their headcount, benefits and current hiring status. This actor reads that directory by city and office type, or fetches named companies directly, returning the same signals you'd see browsing the site by hand.

### What this actor does

- **Two modes**: browse the directory by US city/market and office arrangement, or look up specific companies by name, slug or BuiltIn URL
- **Covers city-specific BuiltIn domains** — Chicago, Colorado, Boston, Seattle, Austin, Atlanta, Los Angeles and the national/all-US listing
- **Filters by office type** — hybrid, on-site or fully remote
- **Optional deep profile fetch** adds website URL, founding year, headquarters and open-jobs count per company, at the cost of one extra request per company
- Fields a company's profile doesn't carry (such as `founded` on a company that doesn't disclose it) are left out of that record rather than sent empty

### Output per company

- `name` — company name
- `slug` — BuiltIn URL slug
- `builtInUrl` — direct link to the company's BuiltIn profile
- `logoUrl` — company logo image URL, when the listing has one (only in `browse` mode)
- `industries` — list of industry/technology tags (up to 10)
- `employeeCount` — number of employees
- `officeCount` — number of office locations
- `benefitsCount` — number of employee benefits listed (only in `browse` mode)
- `isHiring` — whether the company is currently marked as actively hiring
- `openJobsCount` — number of open job listings (only with `includeProfile: true` or `byCompany` mode)
- `websiteUrl` — the company's official website (only with `includeProfile: true` or `byCompany` mode)
- `founded` — year the company was founded (only with `includeProfile: true` or `byCompany` mode)
- `headquarters` — headquarters location (only with `includeProfile: true` or `byCompany` mode)
- `description` — company description
- `sourceUrl` — the BuiltIn listing or profile page the record was read from
- `recordType` — set to `company` for every record
- `scrapedAt` — ISO 8601 timestamp of the scrape

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `browse` | `browse` (list companies from the directory) or `byCompany` (fetch specific companies). |
| `location` | string | – (all US) | US city/market to browse: `chicago`, `colorado`, `boston`, `seattle`, `austin`, `atlanta`, `los-angeles` or `national` (same listing as all-US; combine with `officeType: remote` for remote-only). |
| `officeType` | string | – (all types) | `hybrid`, `on-site` or `remote`. |
| `companyUrls` | array | `[]` | Company URLs, names or slugs to fetch directly, e.g. `https://builtin.com/company/stripe`, `openai` or `Microsoft` (mode=`byCompany`). |
| `includeProfile` | boolean | `false` | Fetch each company's full profile page for website, founding year, headquarters and open-jobs count. Slower but more complete. |
| `maxItems` | integer | `50` | Hard cap on companies returned (1–500). |

#### Example: browse all US tech companies

```json
{
    "mode": "browse",
    "maxItems": 50
}
```

#### Example: hybrid companies in Chicago

```json
{
    "mode": "browse",
    "location": "chicago",
    "officeType": "hybrid",
    "maxItems": 30
}
```

#### Example: specific companies with full profiles

```json
{
    "mode": "byCompany",
    "companyUrls": ["https://builtin.com/company/stripe", "openai", "Microsoft"],
    "includeProfile": true
}
```

### Use cases

- **Talent acquisition** — find tech companies in a target city that are actively hiring
- **Sales prospecting** — build lead lists of growing tech companies filtered by headcount and hiring signals
- **Market mapping** — survey the tech company landscape and industry mix in a given city
- **Competitive research** — track a set of named competitors' headcount, benefits and open-roles count over time
- **Job search** — browse companies by work-arrangement preference (hybrid, remote or on-site)

### FAQ

**Do I need an account or API key?**
No. BuiltIn's company directory and profiles are publicly accessible without login.

**What does `includeProfile` add, and why is it off by default?**
It fetches each company's full profile page to add `websiteUrl`, `founded`, `headquarters` and `openJobsCount`. It's off by default because it adds one extra request per company, making runs slower.

**Can I filter the directory by industry?**
Not directly — `browse` mode filters by city and office type only. Each returned record includes `industries`, so you can filter client-side, or use `byCompany` mode if you already know the companies you want.

**Why is `national` the same as "All US"?**
BuiltIn doesn't maintain a separate nationwide-remote listing; `national` points at the same all-US directory as leaving `location` empty. Combine it with `officeType: remote` to see remote-only companies.

**Why might `founded` or `headquarters` be missing even with `includeProfile` on?**
Those fields depend on what the company itself discloses on its BuiltIn profile; if a company hasn't filled them in, there's nothing for the actor to extract.

**How current is the data?**
Every run reads BuiltIn live, so results reflect whatever the companies have published at run time — profiles are self-reported and maintained by the companies themselves.

**Is this affiliated with BuiltIn?**
No, this is an independent, third-party actor that reads BuiltIn's public company directory and profiles. It is not affiliated with or endorsed by Builtin.com, Inc.

# Actor input Schema

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

What to scrape. `browse` lists companies from the BuiltIn directory. `byCompany` fetches specific company profiles by name or BuiltIn URL.

## `location` (type: `string`):

Filter companies by US city/market. Leave empty for all US companies. Note: `national` uses the same builtin.com listing as "All US" (BuiltIn has no separate national-remote listing) — combine with `officeType: remote` to get remote-only companies.

## `officeType` (type: `string`):

Filter by work arrangement.

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

BuiltIn company URLs (e.g. `https://builtin.com/company/stripe`) or company names (e.g. `Stripe`). Slugs like `stripe` also accepted.

## `includeProfile` (type: `boolean`):

If true, fetch each company's full profile page for additional details. Slower but more complete.

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

Hard cap on total records emitted.

## Actor input object example

```json
{
  "mode": "browse",
  "location": "",
  "officeType": "",
  "companyUrls": [],
  "includeProfile": false,
  "maxItems": 20
}
```

# Actor output Schema

## `companies` (type: `string`):

Dataset containing all scraped company profiles.

# 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 = {
    "mode": "browse",
    "location": "",
    "officeType": "",
    "companyUrls": [],
    "includeProfile": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/builtin-tech-company-directory-and-hiring-signal").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 = {
    "mode": "browse",
    "location": "",
    "officeType": "",
    "companyUrls": [],
    "includeProfile": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/builtin-tech-company-directory-and-hiring-signal").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 '{
  "mode": "browse",
  "location": "",
  "officeType": "",
  "companyUrls": [],
  "includeProfile": false,
  "maxItems": 20
}' |
apify call nimbryxo-studio/builtin-tech-company-directory-and-hiring-signal --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/builtin-tech-company-directory-and-hiring-signal"
        }
    }
}
```

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/HFvvKHaMabeeMs0Fa/builds/Hiis0Nd3mktCXsyek/openapi.json