Skip to content

For recruitment process outsourcing providers

One screening method across every client program

Each client brings its own ATS, its own rules and its own retention policy. Put HireLayer behind your integration layer to parse applications, structure requisitions and document screening the same way for all of them, with each client’s references carried through.

Three client programs, each on its own ATS, connect to the RPO provider's integration layer, which holds client configuration, field mapping and write-back. The integration layer calls three HireLayer endpoints: parsing, criteria extraction and scoring. An event log shows parse and score calls with client-prefixed references and per-client retention settings.

What makes RPO delivery hard to standardize

You sell a consistent process. Your clients’ systems, contracts and hiring managers pull in the opposite direction.

  1. 01

    Every client runs a different stack

    Recruiters work in several ATSs in the same week, each structuring candidates differently, or not at all.

  2. 02

    Screening varies by recruiter

    The same requisition type is screened differently from one program to the next, and it shows in client reviews.

  3. 03

    Retention rules differ per contract

    One client allows candidate data to be retained by sub-processors, another forbids it.

  4. 04

    Every result must trace back

    Audits and disputes require linking a screening outcome to the client’s own application record.

Same endpoints, client-specific rules

Per-client settings live in your integration layer and reach HireLayer as request fields. A sketch of how three programs could differ.

Configuration for three client programs. Each sets its HireLayer workspace, whether do_not_store_data is true, who signs off the criteria and what is written back to the client ATS.
The screening note written back to the client's ATS for one applicant: three criteria with met, partial and unknown statuses, a score of 0.78, and the HireLayer request id kept for audit.

Inside your integration layer

Client ATSs connect to your delivery platform. Your platform calls HireLayer with each client’s settings and writes results back.

  1. Your system

    Step 1, your system: An application lands in a client ATS

    Your integration picks it up through the client’s API or webhook.

  2. HireLayer

    Step 2, HireLayer API: Parse with the client’s reference

    HireLayer-Workspace carries the client, application_id the application reference; do_not_store_data follows the client’s contract.

    POST /api/v4/resumes/parse

    • request_id
    • application_id
  3. HireLayer

    Step 3, HireLayer API: Structure the requisition once

    At kickoff, extract criteria and have the hiring manager sign them off.

    POST /api/v4/jobs/extract-criteria

    • job_id
    • criteria[]
  4. HireLayer

    Step 4, HireLayer API: Screen each applicant

    Evaluate against the validated criteria and keep statuses and explanations as the screening note.

    POST /api/v4/resumes/score

    • scores[].score
    • scores[].criteria[]
  5. Your system

    Step 5, your system: Write back to the client ATS

    Push structured fields and the screening note to the client record, with request_id kept for audit.

Planning a multi-program rollout? We can walk through volumes and Enterprise terms.

Book a call

Parse for a client, with no retention

The same call for every program; only the workspace and the retention flag change with the client’s configuration. Without storage nothing is kept, so application_id comes back null: map the answer to the client record on your side. do_not_store_data comes with a paid plan.

HireLayer-Workspace
The client’s id, letters, digits and . _ : ~ -, up to 200 characters: its resumes, jobs and scores stay apart.
do_not_store_data
Set per request from the client’s contract.
request_id
Keep it with the write-back for audit and support.
Request · cURL/api/v4/resumes/parse
curl -X POST https://hirelayer.co/api/v4/resumes/parse \
  -H "X-API-Key: $HIRELAYER_API_KEY" \
  -H "HireLayer-Workspace: acme-retail" \
  -F "file=@application_88412.pdf" \
  -F "do_not_store_data=true"
Response · abridged
{
  "application_id": null,
  "request_id": "fe075a87-0a55-4534-babb-37141c2bcbc2",
  "stored": false,
  "already_stored": false,
  "resume": {
    "info_resume": { "language": "EN", "text": "…" },
    "info_candidate": {
      "full_name": "Jordan Ellis",
      "job_title": "Payroll Specialist",
      "experience_level": "5 to 10 years"
    }
  },
  "warnings": [],
  "credits_used": 1
}

What your delivery organization gains

  • A shared screening standard

    Every program uses the same criteria format and the same status scale.

  • Contract-aware processing

    Retention is set per request, so one integration serves clients with different policies.

  • Traceable results

    application_id and the request_id of each parse link the profile to the client record and to the API call.

  • Recruiters stay accountable

    Statuses inform the screen; decisions and client communication stay with your team.

The HireLayer APIs behind this workflow

Start with the core APIs, add the others when a feature needs them. All six products share one API key and one credit balance.

RPO providers: frequently asked questions

Do you integrate directly with our clients’ ATSs?

No. HireLayer has no ATS connectors. Your integration layer, which already talks to each client ATS, calls the API and writes results back.

How do we keep each client’s data separate?

Send each client’s id in the HireLayer-Workspace header: its resumes, jobs and scores stay in that client’s workspace, never mix with another client’s, and go in one call when the client leaves. Set do_not_store_data for clients whose contract forbids retention by sub-processors.

Can hiring managers edit the criteria?

Yes. Extracted criteria are plain JSON. Hiring managers can change labels, weights or requirement levels, one criterion at a time or by sending the edited list with the job, and Resume Scorer uses the edited list from then on.

How is usage billed across programs?

All calls draw from one credit balance: 1 credit per resume parsed, per resume scored, per search and per skills call, while job criteria are free. Log each call per program to allocate usage. The Enterprise plan covers custom volumes and integration needs.

Can screening run on a callback instead of waiting?

Parsing and scoring are synchronous and also accept a webhook_url for a signed callback. Your integration can use either pattern.

Pilot it on one program

Start with one requisition type in one client program, then extend program by program. The free plan includes 50 credits a month, shared by all six products.