# GTM Hiring Signal Scraper (`mambalabs/gtm-hiring-signal-scraper`) Actor

Detect companies actively hiring GTM teams. Scrapes Greenhouse, Lever, and Ashby ATS boards for Sales, RevOps, and Growth roles. Flat JSON output built for Clay enrichment columns. Pay per result.

- **URL**: https://apify.com/mambalabs/gtm-hiring-signal-scraper.md
- **Developed by:** [Mamba Labs](https://apify.com/mambalabs) (community)
- **Categories:** Lead generation, Jobs, Developer tools
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

## GTM Hiring Signal Scraper

Detect which companies are actively building their GTM teams before your competitors do.

This Actor scrapes **Greenhouse**, **Lever**, and **Ashby** ATS job boards to identify companies posting Sales, RevOps, and Growth roles. Built for outbound teams and Clay users who want to turn hiring signals into pipeline.

---

### Why Hiring Signals Matter

When a company posts for an Account Executive, Sales Development Rep, or VP of Sales, they are signaling pipeline investment. That is one of the strongest buying triggers for:

- Sales tools and infrastructure (CRM, sequencing, RevOps tooling)
- GTM agencies and consultants
- Recruiting and staffing firms
- Sales training and coaching platforms

This Actor handles signal detection for you, at scale, across three major ATS platforms. Output is designed to map directly into Clay columns.

---

### Features

- **Three ATS platforms in one call.** Greenhouse, Lever, and Ashby checked in cascade. Stops at first match to minimize cost.
- **GTM-specific filtering.** Only returns roles that signal pipeline investment (AE, SDR, BDR, RevOps, CS, Growth, VP Sales, CRO, and more). No noise from engineering or finance postings.
- **Signal tags included.** Every result includes a `gtm_signals` array (e.g. `["AE", "SDR", "RevOps"]`) for easy Clay formula filtering.
- **Two input modes.** Single domain for Clay enrichment row-by-row, or batch mode for bulk list processing.
- **Flat JSON output.** Every field is a top-level key. No nested objects to unwrap in Clay.
- **Error-safe.** Each domain is wrapped in try/catch. One failure never stops the run.

---

### Input

```json
{
  "mode": "single",
  "domain": "stripe.com",
  "include_role_details": true
}
````

For bulk processing:

```json
{
  "mode": "batch",
  "domains": ["stripe.com", "linear.app", "ramp.com", "notion.so"],
  "include_role_details": true
}
```

#### Input Fields

| Field | Type | Required | Description |
|---|---|---|---|
| `mode` | string | No | `single` (default) or `batch` |
| `domain` | string | Yes (single mode) | Company domain, e.g. `stripe.com` |
| `domains` | array | Yes (batch mode) | Array of company domains |
| `include_role_details` | boolean | No | Include full job list in output. Default: `true` |

***

### Output

One result object per domain, pushed to the Apify dataset.

```json
{
  "domain": "stripe.com",
  "company_name": "Stripe",
  "ats_detected": "greenhouse",
  "gtm_role_count": 12,
  "gtm_roles": [
    {
      "title": "Enterprise Account Executive",
      "department": "Sales",
      "location": "San Francisco, CA",
      "url": "https://boards.greenhouse.io/stripe/jobs/10001"
    },
    {
      "title": "Revenue Operations Manager",
      "department": "Revenue Operations",
      "location": "Remote",
      "url": "https://boards.greenhouse.io/stripe/jobs/10002"
    }
  ],
  "gtm_signals": ["AE", "RevOps", "CS"],
  "scraped_at": "2026-04-03T12:00:00Z",
  "error": null
}
```

If no GTM roles are found:

```json
{
  "domain": "example.com",
  "company_name": null,
  "ats_detected": null,
  "gtm_role_count": 0,
  "gtm_roles": [],
  "gtm_signals": [],
  "scraped_at": "2026-04-03T12:00:00Z",
  "error": null
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `domain` | string | The input domain |
| `company_name` | string | Derived from domain (first segment) |
| `ats_detected` | string | `greenhouse`, `lever`, `ashby`, or `null` |
| `gtm_role_count` | integer | Number of GTM roles detected |
| `gtm_roles` | array | List of role objects (title, department, location, url) |
| `gtm_signals` | array | Deduplicated signal tags, e.g. `["AE", "SDR", "RevOps"]` |
| `scraped_at` | string | ISO timestamp of the run |
| `error` | string | Error message if scraping failed, otherwise `null` |

***

### GTM Signal Tags

The `gtm_signals` array uses these standardized tags:

| Tag | Triggered by |
|---|---|
| `AE` | Account Executive roles |
| `SDR` | Sales Development Representative |
| `BDR` | Business Development Representative |
| `BizDev` | Business Development (non-SDR) |
| `RevOps` | Revenue Operations |
| `SE` | Sales Engineer |
| `CS` | Customer Success |
| `AM` | Account Manager |
| `DemandGen` | Demand Generation |
| `Growth` | Growth roles |
| `Partnerships` | Partnerships and Channel |
| `ChannelSales` | Channel Sales |
| `FieldSales` | Field Sales |
| `InsideSales` | Inside Sales |
| `VPSales` | VP of Sales |
| `HeadOfSales` | Head of Sales |
| `CRO` | Chief Revenue Officer |
| `SalesManager` | Sales Manager |
| `SalesDirector` | Sales Director |
| `SalesOps` | Sales Operations |

***

### Using This Actor in Clay

This Actor is built to work natively as a Clay enrichment column.

**Setup:**

1. In your Clay table, add a new column
2. Select **Apify** from the integrations panel
3. Choose **GTM Hiring Signal Scraper** (`mambalabs/gtm-hiring-signal-scraper`)
4. Map your `domain` column to the `domain` input field
5. Set `mode` to `single`
6. Run the enrichment

**Output mapping in Clay:**

After the run, map these output fields to named Clay columns:

- `ats_detected` → which ATS the company uses
- `gtm_role_count` → number of open GTM roles (filter: greater than 0)
- `gtm_signals` → use Clay's contains formula to filter for specific signals
- `gtm_roles[0].title` → top GTM role title

**Example Clay filter:** `gtm_role_count > 2` AND `gtm_signals contains "AE"` — identifies companies aggressively building an AE team.

***

### Supported ATS Platforms

| Platform | Endpoint Used | Notes |
|---|---|---|
| Greenhouse | `api.greenhouse.io/v1/boards/{slug}/jobs` | Public API, no auth required |
| Lever | `api.lever.co/v0/postings/{slug}` | Public API, no auth required |
| Ashby | `api.ashbyhq.com/posting-api/job-board/{slug}` | Public API, draft jobs excluded |

The Actor checks Greenhouse first, then Lever, then Ashby. As soon as one platform returns GTM roles, it stops to minimize cost per run.

***

### Pricing

**Pay per result.** Each domain processed = 1 billable event.

Typical run costs:

- 100 domains: ~$0.12
- 1,000 domains: ~$1.20
- 10,000 domains: ~$12.00

***

### Limitations

- ATS slug derivation is based on the first segment of the domain (e.g. `stripe.com` → `stripe`). Companies with unusual ATS slugs that don't match their domain may return zero results.
- Only Greenhouse, Lever, and Ashby are supported in v1.0. Workday, BambooHR, and LinkedIn Jobs are not yet covered.
- Role detection is keyword-based. Unusual job title formats may not be classified.
- No proxy required — all sources are public APIs.

***

### Issues and Feature Requests

Found a bug or want to request a new ATS platform or signal type? Open an issue in the Issues tab above. Response time: typically within 48 hours.

***

### Related Actors

- [GTM Tech Stack Signal Scraper](https://apify.com/mambalabs/gtm-tech-stack-signal-scraper) - Detect which GTM tools a company uses. CRM, sequencer, revenue intelligence. $0.07/result.
- [GTM Signals Aggregator](https://apify.com/mambalabs/gtm-signals-aggregator) - Run both hiring signals and tech stack detection in one call. $0.12/result vs $0.14 if run separately. Saves 14% and adds a composite signal score.

***

Built by [Mamba Labs](https://apify.com/mambalabs).

# Actor input Schema

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

Run mode: single domain or batch list

## `domain` (type: `string`):

Company domain to check, e.g. stripe.com

## `domains` (type: `array`):

List of company domains for batch processing

## `include_role_details` (type: `boolean`):

Include full job listing details in output

## Actor input object example

```json
{
  "mode": "single",
  "include_role_details": true
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("mambalabs/gtm-hiring-signal-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("mambalabs/gtm-hiring-signal-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 '{}' |
apify call mambalabs/gtm-hiring-signal-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GTM Hiring Signal Scraper",
        "description": "Detect companies actively hiring GTM teams. Scrapes Greenhouse, Lever, and Ashby ATS boards for Sales, RevOps, and Growth roles. Flat JSON output built for Clay enrichment columns. Pay per result.",
        "version": "0.0",
        "x-build-id": "UxT3z3yZmmDlskSwS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mambalabs~gtm-hiring-signal-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mambalabs-gtm-hiring-signal-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/mambalabs~gtm-hiring-signal-scraper/runs": {
            "post": {
                "operationId": "runs-sync-mambalabs-gtm-hiring-signal-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/mambalabs~gtm-hiring-signal-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-mambalabs-gtm-hiring-signal-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "single",
                            "batch"
                        ],
                        "type": "string",
                        "description": "Run mode: single domain or batch list",
                        "default": "single"
                    },
                    "domain": {
                        "title": "Domain",
                        "type": "string",
                        "description": "Company domain to check, e.g. stripe.com"
                    },
                    "domains": {
                        "title": "Domains (batch mode)",
                        "type": "array",
                        "description": "List of company domains for batch processing",
                        "items": {
                            "type": "string"
                        }
                    },
                    "include_role_details": {
                        "title": "Include role details",
                        "type": "boolean",
                        "description": "Include full job listing details in output",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```