Extract a job posting
A job posting is really a form pretending to be an article — title, location, salary band, requirements, and description all mixed into free-flowing HTML that differs on every careers site. This job posting extraction API reads a vacancy the way a recruiter would and returns it as structured fields, ready for a database instead of a paragraph of prose.
Run it online
Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.
The problem with job pages specifically
Careers sites are some of the least standardized pages on the web: one company lists salary as a clear range, another buries it in a single sentence near the bottom, and a third omits it entirely. Requirements sometimes sit in a bulleted list and sometimes read as a single dense paragraph. The job-extract endpoint is tuned for this variability, identifying the role title, location, employment type, salary information when present, and the core requirements regardless of how loosely the page is structured.
How the extraction works end to end
You send a job posting URL to POST /web/job-extract, receive a task_id immediately, and the task processes asynchronously in the background. The result comes back as structured fields — job title, company, location, employment type, salary range if disclosed, and a cleaned requirements and description block — delivered by signed webhook or a signed link that stays valid for 24 hours.
Where structured vacancy data gets used
Job aggregators need consistent fields to power search filters like salary range or remote versus on-site. Recruiting agencies track when specific companies post roles matching a client's profile. Compensation analysts build salary benchmarks by pulling posted ranges across an industry. Each of these depends on turning inconsistent job pages into a common schema, which is exactly what manual copying can't do at any real volume.
Why salary transparency changes what's extractable
Pay transparency laws adopted in a growing number of jurisdictions over the past several years have pushed more employers to publish a salary range directly on the posting rather than withholding it until an interview. That shift means structured extraction increasingly captures real compensation data, not just role descriptions — though the field is left empty whenever a posting genuinely doesn't disclose it, rather than guessed at.
Keeping a vacancy feed current
Because failed tasks are never billed — three retries, then a clear error — this endpoint suits a recurring crawl of career pages to catch new postings or detect when a listing is taken down, feeding a job board or an internal talent-intelligence dashboard without a human checking each page.
What you can do with it
Job board aggregation
An aggregator pulls postings from dozens of company career pages and normalizes them into one searchable format.
Recruiting agency lead generation
An agency monitors target companies for new openings that match a client's hiring mandate.
Compensation benchmarking
A People Ops team gathers disclosed salary ranges across an industry to calibrate its own offer bands.
Competitive hiring intelligence
A startup tracks which roles a competitor is actively hiring for as a signal of where they're investing.
FAQ
Does the scrape job postings API extract salary information?
Yes, when a posting discloses a salary or salary range, it's captured as a structured field; if the posting doesn't disclose it, the field is simply left empty.
Is there a free tier for the job posting extraction API?
There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.
What does the job posting extraction API cost?
It's $0.046 per request plus $0.0145 per URL, charged only when the extraction succeeds.
What fields does it return besides the job title?
Typically company, location, employment type, salary range if disclosed, and a cleaned requirements and description section.
Can I process many job postings in bulk?
Yes, submit a batch of vacancy URLs and each is processed and billed individually at the per-URL rate.
What happens if a careers page fails to load?
The task retries automatically up to three times before returning a clear error, and a failed task is never charged.
How is the extracted job data delivered?
Via a signed webhook, recommended for pipelines, or a signed link that remains valid for 24 hours.
Does it work across different applicant tracking systems and career sites?
Yes, it's built to handle the variability across different job page layouts rather than depending on one specific template.
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/web/job-extract \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"url":"https://ejemplo.com"}'const res = await fetch("https://api.kit.forhosting.com/web/job-extract", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"url": "https://ejemplo.com"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/web/job-extract",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"url": "https://ejemplo.com"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/job-extract", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"url":"https://ejemplo.com"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"url":"https://ejemplo.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/job-extract", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"url": "https://ejemplo.com"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "web.job_extract",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
timeout_sec | 30 |
max_crawl_pages | 25 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
422 | task_failed | The task failed after 3 retries. You are never charged for it. |