All platforms

HireBridge Jobs API.

Pull full descriptions, departments, and geocoded locations from any HireBridge career center through a single JSON listings endpoint and Jobo's unified jobs API.

Get API access
HireBridge
Live
<3haverage discovery time
1hrefresh interval
Developer tools

Try the API.

Test Jobs and Feed endpoints against https://connect.jobo.world with live request/response examples, then copy ready-to-use curl commands.

What's in every response.

Data fields, real-world applications, and the companies already running on HireBridge.

Data fields
  • Full Job Descriptions
  • Structured Locations (City, State & Geo)
  • Department, Division & Business Unit
  • Employment & Pay Type
  • Remote Work Classification
  • Posted & Created Dates
Use cases
  1. 01Job board aggregation
  2. 02Mid-market hiring signals
  3. 03Location-based job search
  4. 04Careers page monitoring
DIY GUIDE

How to scrape HireBridge.

Step-by-step guide to extracting jobs from HireBridge-powered career pages—endpoints, authentication, and working code.

RESTintermediateNo published limit; ~200ms between requests recommendedNo auth

Resolve the company id (cid)

Every HireBridge career center is keyed by a numeric company id (cid) that appears in the public URL. Extract it from the career-center link before calling the API.

Step 1: Resolve the company id (cid)
from urllib.parse import urlparse, parse_qs

# Public career center: https://recruit.hirebridge.com/v3/careercenter/v2/?cid=8116
url = "https://recruit.hirebridge.com/v3/careercenter/v2/?cid=8116"
cid = parse_qs(urlparse(url).query)["cid"][0]
print(cid)  # "8116"

Fetch a page of listings as JSON

Call the GetJobListings endpoint on hbapi.hirebridge.com with a startrow/endrow range. Force Accept: application/json — with a browser-default Accept header the WebMethod returns an XML <string> envelope instead. The JSON array is also double-encoded (wrapped in a JSON string), so unwrap it once before parsing.

Step 2: Fetch a page of listings as JSON
import json
import requests

def fetch_page(cid: str, start_row: int, end_row: int) -> list[dict]:
    url = "https://hbapi.hirebridge.com/careercenter/v2/GetJobListings"
    params = {
        "cid": cid,
        "language": "en",
        "startrow": start_row,
        "endrow": end_row,
    }
    resp = requests.get(
        url,
        params=params,
        headers={"Accept": "application/json"},
        timeout=15,
    )
    resp.raise_for_status()

    # WebMethod wraps the array in a JSON string: "\"[{...}]\"".
    payload = json.loads(resp.text)
    if isinstance(payload, str):
        payload = json.loads(payload)
    return payload or []

jobs = fetch_page("8116", 1, 100)
print(f"Fetched {len(jobs)} jobs")

Paginate with startrow/endrow

The endpoint pages through an inclusive 1-based row range. Request fixed-size windows and stop once a page returns fewer rows than the batch size — that signals the last page.

Step 3: Paginate with startrow/endrow
def fetch_all(cid: str, batch_size: int = 100) -> list[dict]:
    all_jobs: list[dict] = []
    start = 1
    while True:
        page = fetch_page(cid, start, start + batch_size - 1)
        all_jobs.extend(page)
        if len(page) < batch_size:
            break
        start += len(page)
    return all_jobs

print(len(fetch_all("8116")))

Map fields and build detail/apply URLs

Field keys are lowercase (joblistid, jobtitle, jobdeptname, ...). Dates come back as US M/d/yyyy with no timezone. Rebuild the canonical detail and apply URLs on recruit.hirebridge.com from the cid and joblistid.

Step 4: Map fields and build detail/apply URLs
def map_job(job: dict, cid: str) -> dict:
    jid = (job.get("joblistid") or "").strip()
    loc = job.get("location") or {}
    return {
        "external_id": jid,
        "title": (job.get("jobtitle") or "").strip(),
        "description": job.get("description") or "",
        "company": job.get("companyname"),
        "department": job.get("jobdeptname"),
        "division": job.get("jobdivisionname"),
        "employment_type": job.get("jobtypename"),
        "pay_type": job.get("payselname"),
        "city": loc.get("city"),
        "state": loc.get("statename") or loc.get("state"),
        "country": loc.get("countryname") or loc.get("country"),
        "is_remote": loc.get("isremote"),
        "posted_at": job.get("publicdate") or job.get("createdate"),  # M/d/yyyy
        "listing_url": f"https://recruit.hirebridge.com/v3/careercenter/v2/details.aspx?jid={jid}&cid={cid}",
        "apply_url": f"https://recruit.hirebridge.com/v3/application/AppLink.aspx?cid={cid}&jid={jid}",
    }

records = [map_job(j, "8116") for j in jobs]
Common issues
highEndpoint returns an XML <string> envelope instead of JSON

The GetJobListings WebMethod does content negotiation on the Accept header. Send Accept: application/json explicitly on every request; a browser-default */* yields XML.

highJSON array is double-encoded (a string wrapping the array)

The payload is often "[{...}]" — a JSON string containing the array. Parse once, and if the result is a str, parse it again before iterating.

mediumEmpty or missing results because the cid is wrong

The API keys everything off a numeric cid. Confirm you pulled the cid query param from the career-center URL; a non-numeric or absent cid returns nothing.

medium403 or 429 responses when crawling aggressively

Serialize requests per company and space them ~200ms apart. Treat 403 and 429 as rate limiting and back off before retrying.

lowDates parsed with the wrong day/month order

publicdate and createdate use US M/d/yyyy with no timezone. Parse with an explicit format and assume UTC so 5/12/2026 is not read as 12 May.

Best practices
  1. 1Always send Accept: application/json to avoid the XML string envelope
  2. 2Unwrap the double-encoded JSON string before parsing the array
  3. 3Paginate with startrow/endrow and stop when a page is shorter than the batch size
  4. 4Keep concurrency at one per company and space requests ~200ms apart to avoid 403/429
  5. 5Parse publicdate/createdate as US M/d/yyyy and normalize to UTC
  6. 6Cache results between runs to avoid re-fetching unchanged listings
Or skip the complexity

One endpoint. All HireBridge jobs. No scraping, no sessions, no maintenance.

Get API access
cURL
curl "https://connect.jobo.world/api/jobs?sources=hirebridge" \
  -H "X-Api-Key: YOUR_KEY"

Related ATS Platforms

Explore other job data integrations

ADP MyJobs100K+/mo
ADP Workforce Now100K+/mo
Ashby100K+/mo
BambooHR80K+/mo
View all platforms
Ready to integrate

Access HireBridge
job data today.

One API call. Structured data. No scraping infrastructure to build or maintain — start with the free tier and scale as you grow.

Get API access View all platforms
99.9%API uptime
<200msAvg response
50M+Jobs processed