Greenhouse Data API: Extract Structured JSON in 2026

TL;DR: To get structured greenhouse data via API, send a POST request to a data API like AlterLab with a target URL and a JSON schema. This bypasses the need for fragile CSS selectors and returns typed JSON containing job titles, locations, and salaries directly.

Disclaimer: This guide covers extracting publicly accessible data. Always review a site's robots.txt and Terms of Service before scraping.

Why use Greenhouse data?

For data engineers and AI researchers, public job boards represent a high-signal stream of market intelligence. Building a dedicated pipeline for Greenhouse data enables several high-value use cases:

• Market Intelligence: Track hiring trends, expansion into new geographic regions, or shifts in tech stacks by monitoring job postings.
• AI Training & RAG: Feed real-time, structured job descriptions into LLMs to power recruitment agents or specialized search engines.
• Competitive Benchmarking: Analyze salary ranges and role requirements to stay competitive in the talent market.

If you are building production-grade pipelines, you should get started here.

What data can you extract?

When targeting public Greenhouse job boards, you aren't just getting raw HTML. You are building a structured dataset. The goal is to transform unstructured web pages into a typed schema.

Typical fields extracted from public Greenhouse pages include:

• job_title: The specific role (e.g., "Senior Staff Engineer").
• company: The hiring organization.
• location: The physical office or "Remote" status.
• salary: Compensation ranges (if disclosed).
• posted_date: When the listing was last updated.
• employment_type: Full-time, contract, or internship.

The extraction approach

Historically, engineers used BeautifulSoup or Selenium to parse Greenhouse pages. This approach is brittle. Greenhouse frequently updates their DOM structure, which breaks CSS selectors and XPath queries. Furthermore, managing headless browsers to handle JavaScript rendering and anti-bot measures is a massive operational overhead.

A modern data API approach treats the web as a structured database. Instead of writing logic to find a <div> with a specific class, you provide a schema. The engine handles the rendering, proxy rotation, and DOM traversal, returning only the data that matches your requirements.

Quick start with AlterLab Extract API

To begin, you don't need to manage a fleet of proxies. You simply define what the data should look like and call the Extract API docs.

Python Implementation

The Python client allows you to pass a JSON schema directly. The engine uses LLM-powered extraction to map the page content to your specific keys.

import alterlab

client = alterlab.Client("YOUR_API_KEY")

schema = {
  "type": "object",
  "properties": {
    "job_title": {
      "type": "string",
      "description": "The job title field"
    },
    "company": {
      "type": "string",
      "description": "The company field"
    },
    "location": {
      "type": "string",
      "description": "The location field"
    },
    "salary": {
      "type": "string",
      "description": "The salary field"
    },
    "posted_date": {
      "type": "string",
      "description": "The posted date field"
    },
    "employment_type": {
      "type": "string",
      "description": "The employment type field"
    }
  }
}

result = client.extract(
    url="https://greenhouse.io/example-page",
    schema=schema,
)
print(result.data)

cURL Implementation

For quick testing in a terminal, use a standard POST request.

curl -X POST https://api.alterlab.io/v1/extract \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://greenhouse.io/example-page",
    "schema": {"properties": {"job_title": {"type": "string"}, "company": {"type": "string"}, "location": {"type": "string"}}}
  }'

Define your schema

The power of a data API lies in validation. By providing a JSON schema, you ensure that your downstream applications receive predictable, typed data. If a field is missing or incorrectly formatted, the engine can attempt to correct it or flag it, preventing your pipeline from crashing due to a sudden change in the source website's layout.

The extraction process follows a simple flow:

Handle pagination and scale

When monitoring an entire company's job board, you will encounter hundreds of URLs. For high-volume extraction, you should move away from synchronous requests and implement an asynchronous batching strategy.

For large-scale operations, we recommend using our asynchronous job pattern. This allows you to submit a batch of URLs and poll for results, which is more efficient for large datasets.

import alterlab

client = alterlab.Client("YOUR_API_KEY")

urls = [
    "https://greenhouse.io/jobs/1",
    "https://greenhouse.io/jobs/2",
    "https://greenhouse.io/jobs/3"
]

schema = {
    "type": "object",
    "properties": {
        "job_title": {"type": "string"},
        "location": {"type": "string"}
    }
}

# Submit batch jobs
jobs = []
for url in urls:
    job = client.extract_async(url=url, schema=schema)
    jobs.append(job)

# Poll for results
for job in jobs:
    result = job.wait()
    print(f"URL: {job.url} | Data: {result.data}")

As your scale increases, keep an eye on your AlterLab pricing. We operate on a pay-as-you-use model. You can use the estimate endpoint to calculate the cost of a request before you commit, which is essential for managing budget in production environments.

Key takeaways

• Schema-first extraction: Stop writing fragile CSS selectors; use JSON schemas to define what you want.
• Data API vs. Scraper: Use a data API to handle rendering, proxies, and anti-bot measures automatically.
• Typed output: Ensure your data pipelines are robust by receiving validated JSON instead of raw HTML.
• Scalability: Use asynchronous jobs for large-scale Greenhouse data extraction to optimize throughput.

Hit reply if you have questions.

AlterLab // Web Data, Simplified.