mcpField
G
GTM Hiring Signal Scraper

GTM Hiring Signal Scraper

Local
github.com/mambalabsdevBrowser Automation1Updated 1w ago

About GTM Hiring Signal Scraper

GTM Hiring Signal Scraper is an MCP server that scans company career pages for go-to-market hiring signals using an Apify actor. It returns flat JSON suited to Clay, CRM, or agent workflows, with single, batch, and change-over-time modes.

Key features

  1. 01Detect supported ATS platforms on career pages
  2. 02Filter and score GTM roles
  3. 03Return flat JSON for Clay mapping
  4. 04Scan multiple company domains in batch
  5. 05Compare role counts between runs

Use cases

  1. 01Check a company for open GTM roles
  2. 02Compare hiring signals across several companies
  3. 03Track changes in GTM role counts on scheduled runs

MCP support

Exposes the `scan_gtm_hiring_signals` tool to MCP clients. The server is a thin client that calls the Apify actor and returns its results.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

mcp.json · Universal config
{
"mcpServers": {
"gtm-hiring-signal-scraper": {
"command": "npx",
"args": [
"-y",
"@mambalabsdev/mcp-gtm-hiring-signal-scraper"
],
"env": {
"APIFY_TOKEN": "<APIFY_TOKEN>"
}
}
}
}
Run commandnpx -y @mambalabsdev/mcp-gtm-hiring-signal-scraper
Environment variables to set
APIFY_TOKENSecretApify API token from https://console.apify.com/account/integrations

Local servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.

Packages
npm@mambalabsdev/mcp-gtm-hiring-signal-scraper1.4.0

Tools

1

Saved tool list · updated 3w ago

ParameterTypeRequiredDescription
domainstringYesBare company domain without https:// and without a trailing slash. Example: stripe.com
role_filterarrayNoOptional list of GTM role keywords to filter on. Defaults to the built-in GTM keyword list if omitted.
ats_slugstringNoOptional ATS board slug override for when it differs from the domain. Example: clay.com uses claylabs on Ashby. If omitted, the scraper auto-probes common slug variants.
modeenumNoProcessing mode. "single" scores the domain. "velocity" compares this run against previous_gtm_role_count and previous_run_date to report role changes since last time. "batch" scores a list of domains and is an actor-level mode this single-call tool does not supply a list for. Default: "single".single | batch | velocity
include_role_detailsbooleanNoWhen true, include the full per-role detail array (title, department, location, url) in the output. Default: false.
previous_gtm_role_countintegerNoGTM role count from the previous run for this domain. Used in velocity mode to compute the delta, which is what makes a scheduled run cheap.
previous_run_datestringNoISO date of the previous run for this domain, e.g. 2026-07-15. Used in velocity mode to report days between runs.

Details

From the project README

GTM Hiring Signal Scraper MCP Server

Smithery Glama score MCP Registry npm version npm downloads license mcpservers.org

Gtm Hiring Signal Scraper MCP server

An MCP server that detects go-to-market hiring activity from company career pages. It wraps the Mamba Labs GTM Hiring Signal Scraper on Apify and returns Clay-ready flat JSON to any MCP client.

What's Inside

What it does

Give it a company domain and it scans that company's job board for sales, marketing, and revenue operations roles across Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Personio. You get back a structured read on how hard that company is hiring for go-to-market, ready to drop into Clay, a CRM, or an AI agent workflow. All of the scraping runs on Apify. This package is a thin client that calls the actor and hands back the result.

Quick start

You need Node.js 18 or newer and an Apify account with an API token.

Add this to your Claude Desktop config:

{
  "mcpServers": {
    "mamba-gtm-hiring": {
      "command": "npx",
      "args": ["-y", "@mambalabsdev/mcp-gtm-hiring-signal-scraper"],
      "env": {
        "APIFY_TOKEN": "your-apify-token"
      }
    }
  }
}

Get your token at https://console.apify.com/account/integrations, paste it in, and restart Claude Desktop. The scan_gtm_hiring_signals tool will be available.

Prerequisites

  • Node.js 18 or newer
  • An Apify account with an API token

Example prompts

  • "Check if stripe.com is hiring for go-to-market roles right now."
  • "Scan openai.com for sales and revenue operations job postings."
  • "Is datadoghq.com ramping up GTM hiring? Use the GTM hiring scanner."
  • "Pull the GTM hiring signal for figma.com and list which roles are open."
  • "Scan stripe.com, figma.com, and notion.so for GTM hiring in one batch."

Inputs

  • domain (required): the bare company domain, no https:// and no trailing slash. Example: stripe.com
  • role_filter (optional): a list of GTM role keywords to filter on. Leave it out to use the built-in keyword list.
  • ats_slug (optional): override the ATS board slug when it differs from the domain. Example: clay.com uses claylabs on Ashby.
  • domains (optional): a list of bare domains scanned in one run when mode is batch, one row per company. domain is still required by the schema, so pass the first domain there too.
  • mode (optional): single (default) scores domain; batch scores every entry in domains; velocity compares this run against previous_gtm_role_count and previous_run_date to report role changes since the last run.
  • include_role_details (optional): when true, adds the full per role array (title, department, location, URL). Default false.
  • previous_gtm_role_count (optional): the GTM role count from your previous run for this domain. Used in velocity mode to compute the delta, which is what makes a scheduled run cheap.
  • previous_run_date (optional): ISO date of your previous run for this domain, for example 2026-07-15. Used in velocity mode to report the days between runs.
  • max_charge_usd (optional): a cost cap in USD for this run. The actor stops before an item that could take its charges past this amount. Omit it to rely on the maximum cost per run set in Apify.

Output

The tool returns the actor's flat JSON for the scanned company. Fields include the detected ATS platform, the count of open GTM roles, the matched role titles and their categories, and a seniority read. Companies on an ATS outside those six come back with a null platform, a zero role count, and no error. See the Apify Store page for the full output schema.

Example output

{
  "domain": "stripe.com",
  "company_name": "Stripe",
  "gtm_hiring_signal": true,
  "ats_platform": "greenhouse",
  "gtm_role_count": 12,
  "signal_strength": "high",
  "top_gtm_role": "Head of Revenue",
  "career_page_url": "https://boards.greenhouse.io/stripe",
  "run_date": "2026-05-28"
}

Features

  • Cascading ATS detection: Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Personio
  • GTM role filtering with 3-tier signal strength (high, medium, low)
  • Flat JSON output designed for Clay column mapping
  • Optional role_filter and ats_slug inputs
  • Batch mode (domains) and velocity mode for scheduled runs

Pricing

Price per event on the Apify FREE plan, from the live pricing record; paid Apify plans pay less per event.

EventPrice (USD)
result (apify-default-dataset-item)0.05
Actor Start (apify-actor-start)0.00005

Full actor documentation

This server is a thin client and holds no scraping logic. For the complete input and output reference, pricing, and run history, see the Apify Store page:

https://apify.com/mambalabs/gtm-hiring-signal-scraper


Mamba Labs GTM Suite

This server is one of 58 Mamba Labs MCP servers, each a thin client for one Mamba Labs actor on Apify. Every actor returns flat, Clay-ready rows that join on the company domain.

Built by Mamba Labs | npm | Apify Store

License

MIT

Built by Mamba Labs. https://apify.com/mambalabs

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.