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.
What makes RPO delivery hard to standardize
You sell a consistent process. Your clients’ systems, contracts and hiring managers pull in the opposite direction.
- 01
Every client runs a different stack
Recruiters work in several ATSs in the same week, each structuring candidates differently, or not at all.
- 02
Screening varies by recruiter
The same requisition type is screened differently from one program to the next, and it shows in client reviews.
- 03
Retention rules differ per contract
One client allows candidate data to be retained by sub-processors, another forbids it.
- 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.
Inside your integration layer
Client ATSs connect to your delivery platform. Your platform calls HireLayer with each client’s settings and writes results back.
- 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.
- 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
- 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[]
- 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[]
- 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 callParse 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.
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"{
"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.
- HireLayer Resume Parser
Resume Parsing API
Core to this workflowDocs for HireLayer Resume ParserParses each application with the client’s reference and retention setting.
- HireLayer Job Criteria Extractor
Job Parsing API
Core to this workflowDocs for HireLayer Job Criteria ExtractorTurns each requisition into criteria the hiring manager signs off.
- HireLayer Resume Scorer
Candidate & Job Matching API
Core to this workflowDocs for HireLayer Resume ScorerProduces a structured screening note for each applicant; its precise_ranking option orders a requisition’s slate before the client review.
- HireLayer Skills Normalizer
Skills Matching API
Add when neededDocs for HireLayer Skills NormalizerResolves skills to one taxonomy for talent reporting across programs.
RPO providers: frequently asked questions
Do you integrate directly with our clients’ ATSs?
How do we keep each client’s data separate?
Can hiring managers edit the criteria?
How is usage billed across programs?
Can screening run on a callback instead of waiting?
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.