Does it fetch jobs from job boards?

No. It only normalizes JSON payloads you send. It does not call LinkedIn, Indeed, or ATS APIs.

Do I need API keys for LinkedIn or Indeed?

No for this API. You obtain job JSON through your own integrations and pass it to /normalize.

Can I mix platforms in one request?

Yes. Send an inputs array with platform buckets (platform plus data array) or inline blocks with platform and payload.

What is the canonical job schema?

A unified structure with id, title, description, company, location, employmentType, experienceLevel, salary, postedDate, applyUrl, jobStatus, provenance, and interpretation (method and confidence).

No. The service is fully stateless.

Where are pricing and quotas defined?

On RapidAPI: Basic is free with 100 requests per month; Pro is $9.99/month with 10,000 requests; Ultra is $49.99/month (recommended) with 100,000 requests; Mega is $99.99/month with 250,000 requests. Overage pricing is shown on the live listing.

Can I request a new platform adapter?

Yes. Open a thread on RapidAPI discussions for the Job Posting Normalization API with the vendor name and a redacted sample JSON payload.

Normalize Job Listings From Any Board Into One Schema

One API call unifies job payloads from LinkedIn, Indeed, Greenhouse, Lever, ZipRecruiter, and 25+ sources into a consistent canonical format — title, company, location, salary, apply URL, provenance, and confidence for search, ATS workflows, and analytics.

Try Job Posting Normalization API Basic on RapidAPI: 100 requests/month free

Stop maintaining dozens of job-board parsers. Replace brittle per-vendor field mapping with one deterministic schema. Ship aggregators and matching pipelines faster—your team spends time on product, not re-parsing every ATS changelog.

Real-world use cases

Normalize webhook or export payloads from boards and ATS before workers or search indexes consume them.
Power job aggregators and talent marketplaces with one JSON shape for filters, cards, and detail views.
Feed warehouses and BI with canonical titles, locations, and salary fields across vendors.
Unify multi-source job search—one schema for ranking, deduplication, and alerts.
Batch mixed platforms in a single POST for nightly ETL from multiple feeds.
Flag low-confidence parses using interpretation.confidence and interpretation.method.

Why not build your own normalizer?

Boards and ATS products change JSON shapes without notice
Salary and location representations differ wildly
Each new source multiplies edge cases

Cross-vendor job normalization is ongoing work. This API centralizes mappings so you benefit when payloads drift.

Who this API helps

HR tech, job aggregators, and ATS integrations
Recruitment marketplaces and matching products
Data teams building unified job datasets
Developers who want repeatable, testable normalization (not scraping or LLM guessing)

Before and after normalization

Vendors use different field names and nesting. The API maps them into one predictable structure (illustrative).

Before (vendor-style payload)

{
  "content": "Join our team…",
  "absolute_url": "https://…"
}

After (canonical shape)

{
  "title": "Senior Engineer",
  "description": "Join our team…",
  "applyUrl": "https://…",
  "company": { … },
  "location": { … },
  "interpretation": { … }
}

What the API does

Send POST /normalize with top-level payload (one job or array) and optional platform, or an inputs array for mixed vendors. The response is JSON with jobs, errors, optional warnings, and metadata. Per-item failures do not fail the whole request.

Unlike scrapers or AI extractors, this API operates on structured JSON you already have and returns a consistent canonical schema every time—deterministic mapping, not probabilistic parsing.

Deterministic by design

The same input payload always produces the same normalized output. No hidden randomness—ideal for tests, CI, and production pipelines that need repeatable results.

Platforms: dedicated parsers vs generic

The platform string selects a normalizer. Some sources have dedicated parsers; others use a shared custom path with heuristics (often lower confidence). Unknown labels route to the same generic path.

Dedicated adapters

Best for known vendor payloads; typically higher confidence.

LinkedIn — linkedin
Indeed — indeed
Glassdoor — glassdoor
ZipRecruiter — ziprecruiter
Monster — monster
CareerBuilder — careerbuilder
Dice — dice
Wellfound / AngelList — wellfound, angellist
Greenhouse — greenhouse
Lever — lever
SmartRecruiters — smartrecruiters
Google Jobs — google_jobs
Ashby — ashby

Reserved keys (custom inference)

These platform values are recognized but use the custom normalizer—useful for consistent routing with heuristic extraction:

simplyhired, jooble, workday, bamboohr, icims, taleo, adp, ukg, jazzhr, bullhorn, recruitee, pinpoint, jobvite, plus custom, generic, unknown

Any other string still normalizes via the custom path.

Want a first-class adapter for a platform? Request it on RapidAPI discussions — include a redacted sample payload and the vendor name.

Request & response schema

Endpoint: POST https://job-posting-normalization-api.p.rapidapi.com/normalize with Content-Type: application/json, plus x-rapidapi-key and x-rapidapi-host.

You must send either top-level payload or an inputs array (not neither).

View request body fields · View inputs shapes · View success response · View HTTP error body · View per-item error codes

Field	Required	Type	Description
`payload`	One of payload / inputs	object \| array	Single job object or array of jobs. Pair with `platform` (and optional `platformVersion`) for single-vendor batches. If `platform` is omitted, `custom` inference is used.
`platform`	No	string	Vendor hint for top-level `payload`. Normalized: lowercase; spaces/hyphens stripped. See Platforms.
`platformVersion`	No	string	Optional API/version hint for parsers that branch on version.
`inputs`	One of payload / inputs	array	Mixed-vendor batch: each element is a bucket `{ "platform": "linkedin", "data": [ …jobs ] }` or an inline block `{ "platform": "greenhouse", "payload": … }` where `payload` is one job or an array of jobs.

Bucket form — many jobs, one platform:

{ "platform": "linkedin", "data": [ { "title": "Engineer", "listedAt": 1704067200000 } ] }

Inline form — flexible per block:

{ "inputs": [
  { "platform": "linkedin", "data": [ { "title": "Role A" } ] },
  { "platform": "greenhouse", "payload": { "id": 1, "title": "Role B", "content": "…" } }
]}

On success the handler returns HTTP 200 with this JSON shape (partial success allowed):

{ "jobs": [ /* CanonicalJob */ ], "errors": [ /* per-item */ ], "warnings": null | string[], "metadata": { "totalInputItems", "normalizedCount", "errorCount" } }

Canonical job (summary): id, title, description, company, location, employmentType, experienceLevel, salary, postedDate, jobStatus, applyUrl, provenance, interpretation (method: platform_exact | platform_fuzzy | generic_inferred, confidence 0–1, optional warnings).

errors — each entry has code, message, optional index (position in flattened stream), optional detail.

When the request is invalid, the API returns a non-200 status and {"error":"...","message":"..."} (not the success envelope):

HTTP	`error`	Meaning
400	`INVALID_REQUEST`	Body missing both `payload` and valid `inputs`
400	`INVALID_JSON`	Body is not valid JSON
413	`PAYLOAD_TOO_LARGE`	Serialized body over 25MB
500	`INTERNAL_ERROR`	Unexpected server failure

Example: {"error":"INVALID_REQUEST","message":"Request body must include \"payload\" or \"inputs\" array"}

Code	HTTP	Description
`INVALID_REQUEST`	`400`	Top-level body missing `payload` and valid `inputs`.
`INVALID_JSON`	`400`	Request body is not valid JSON.
`INVALID_PAYLOAD`	`200`	Per-item: not a recognizable job object (e.g. wrong shape, empty).
`PARSE_ERROR`	`200`	Per-item: unexpected failure while normalizing that item.
`PAYLOAD_TOO_LARGE`	`413`	Request size exceeds 25MB.
`INTERNAL_ERROR`	`500`	Unhandled server exception.

Per-item problems still return HTTP 200 with entries in errors; other jobs in the batch still normalize.

Try it in the playground

Pick a sample request (or edit JSON), add your RapidAPI key, run, then copy code in the language you use below. The key is sent only to RapidAPI.

RapidAPI Key (required)

Sample request

Loads a template into the JSON editor; you can change anything before running.

Request body (JSON)

Subscribe on RapidAPI for production keys and plan details.

Get code

Generates a snippet for the JSON currently in the playground. Choose language, refresh if you edited the body, then copy.

Integration time: Under 5 minutes with any stack that can send HTTP POST and JSON headers.

Real-world examples

1. Greenhouse board export (single job)

Your worker receives a job object from Greenhouse. Send it with platform: "greenhouse" so title, description, location, and apply URL map with the dedicated adapter.

{
  "platform": "greenhouse",
  "payload": {
    "id": 12345,
    "title": "Senior Engineer",
    "content": "We are looking for a senior engineer.",
    "location": { "name": "New York, NY" },
    "absolute_url": "https://boards.greenhouse.io/company/jobs/12345"
  }
}

2. Nightly batch from LinkedIn + Greenhouse

Aggregation pulls buckets per vendor. One POST merges them into a single jobs array for your index or warehouse.

{
  "inputs": [
    {
      "platform": "linkedin",
      "data": [
        { "externalJobPostingId": "123", "title": "Engineer", "listedAt": 1704067200000 }
      ]
    },
    {
      "platform": "greenhouse",
      "data": [
        { "id": 456, "title": "Designer", "content": "Join us.", "location": { "name": "Remote" } }
      ]
    }
  ]
}

Pricing & tiers (RapidAPI)

Built for production job data pipelines that need deterministic, canonical outputs across heterogeneous boards and ATS—search indexes, matching engines, and analytics.

Current plans on RapidAPI:

Basic

$0/mo

Primary: 100/month

Pro

$9.99/mo

Primary: 10,000/month

Recommended

Ultra

$49.99/mo

Primary: 100,000/month, then $0.003 each

Mega

$99.99/mo

Primary: 250,000/month, then $0.002 each

If RapidAPI pricing or quotas change, the live listing is authoritative.

What to expect

Successful calls return HTTP 200 and Content-Type: application/json with jobs, errors, warnings, and metadata. Invalid top-level requests return 400, 413, or 500 with {"error":"...","message":"..."}. Use your RapidAPI key on every request. Stateless — no payload storage.

About this API

Who Should Use This API

HR tech, job aggregators, ATS and recruitment platforms needing one job schema.

Also Known As

Job listing normalizer, job board unifier, job data normalization API.

Job Posting Normalization API

Normalize job postings from LinkedIn, Indeed, Greenhouse, Lever, SmartRecruiters, ZipRecruiter, Ashby, and 25+ job boards and ATS into one canonical job schema. One API call for single or mixed sources—no per-platform parsers. Built for job aggregators, search indexes, and analytics pipelines that need a single, unified data model.

What This API Does

**Normalizes** raw payloads from any supported platform (LinkedIn, Indeed, Greenhouse, Lever, SmartRecruiters, ZipRecruiter, Ashby, Google Jobs, Dice, Wellfound, and more) into one consistent JSON shape
**Single schema** — Every job becomes the same structure: id, title, description, company, location, employmentType, experienceLevel, salary, postedDate, applyUrl, plus provenance and confidence
**Mixed platforms in one request** — Send an array of vendor buckets (platform + data per bucket); get one combined `jobs` array. Or call once per source and merge results for parallel ingestion
**Confidence & provenance** — Each normalized job includes interpretation method (platform_exact, platform_fuzzy, generic_inferred) and confidence score so you can filter or flag low-confidence items
**No vendor keys** — You send your own raw JSON; the API does not fetch or scrape. Stateless, 25MB max payload

**One pipeline, one schema.** Build search, matching, or analytics on a single canonical shape instead of maintaining dozens of platform-specific parsers.

Key Features

**Stateless** — No data stored or logged; 25MB max request
**25+ platforms** — LinkedIn, Indeed, Glassdoor, ZipRecruiter, Monster, CareerBuilder, Dice, Wellfound, Greenhouse, Lever, SmartRecruiters, Ashby, Google Jobs, and more; unknown use custom fallback
**Single or mixed** — One object with platform + payload, or array of inputs (platform + data per bucket); optional custom for unknown schemas
**Canonical output** — id, title, description, company, location, employmentType, experienceLevel, salary, postedDate, applyUrl, provenance, interpretation (method + confidence)
**Errors & warnings** — Per-item errors (e.g. INVALID_PAYLOAD) and non-fatal warnings (e.g. platform mismatch) so you know what succeeded and what didn't

Use Cases

**Job aggregation & search** — Aggregate listings from multiple job boards and ATS into one dataset for search, filters, or matching
**Data pipelines & ETL** — Ingest job JSON from webhooks, scrapers, or APIs; normalize in one step before loading into a warehouse or search index
**Unified job feed** — Index jobs from LinkedIn, Indeed, Greenhouse, etc. with one schema so one search layer works across all sources
**Multi-threaded ingestion** — Call the API as each source returns data; combine the `jobs` arrays at the end for parallel fetching with a single unified output

Frequently asked questions

No. It only normalizes JSON payloads you send. It does not call LinkedIn, Indeed, Greenhouse, or other vendor APIs on your behalf.
No for this endpoint. You use your RapidAPI key here only. You obtain job JSON through your own integrations and POST it to /normalize.
Yes. Use an inputs array: each item can be a bucket { platform, data: job[] } or { platform?, payload } with one job or an array. You get one combined jobs array.
A unified structure with id, title, description, company, location, employmentType, experienceLevel, salary, postedDate, applyUrl, jobStatus, provenance, and interpretation (method and confidence).
25MB per request.
No. The service is fully stateless.
On RapidAPI: Basic is free with 100 requests/month; Pro ($9.99/mo) includes 10,000/month; Ultra ($49.99/mo, recommended) includes 100,000/month; Mega ($99.99/mo) includes 250,000/month—with overage rules as shown on the listing.
Yes. Open a thread on RapidAPI discussions with the vendor name and a redacted sample JSON payload.

Browse all APIs in the catalog →