For HR software vendors

Recruiting features for your HR product, without building the models

HireLayer is the backend behind features your users see under your brand: profiles created from a CV, job requirements drafted from a description, skill tags that stay consistent across customers. Your product keeps the interface, the tenant model and the data.

A white-label HR product showing a job requirements editor. Four requirements drafted from the job description have weights and a must-have toggle. A server log shows the product's backend calling the HireLayer criteria extraction endpoint and saving the result as a draft.

The problem

Why recruiting features stall on HR roadmaps

Customers ask for “AI” in the recruiting module. Behind that request are four separate capabilities, and none of them is your core product.

  1. 01

    Each feature is a different model to build

    Reading CVs, interpreting job ads, normalizing skills and comparing profiles are four problems. Solving them in-house competes with payroll, onboarding or performance work.

  2. 02

    Your customers expect your interface

    An embedded third-party screen breaks your design system, your permissions model and your support flow.

  3. 03

    Skill data drifts across tenants

    “JS”, “Javascript” and “JavaScript developer” end up as three tags. Search and reporting across customers stop being reliable.

  4. 04

    Retention rules differ per customer

    Some tenants accept processing and storage by a sub-processor, others do not. The integration has to respect that on every request.

Feature catalog

Five features on one integration

Each card is a feature your users would see, the endpoint behind it and the fields you render. Ship one, then add the next on the same API key.

  • Create a profile from a CV

    POST /api/v3/parser

    info_candidatework_experiences[]educations[]
    Product details
  • Draft job requirements

    POST /api/v1/jobs/extract-criteria

    labelweightis_mandatory
    Product details
  • Suggest skill tags

    POST /api/v1/skills/match

    skillsimilarity_scoredomain
    Product details
  • Explain a candidate’s fit

    POST /api/v1/matching/job-candidate

    match_statusmatch_explanation
    Product details
  • Order a shortlist

    POST /api/v1/matching/job-candidates/rank

    rankscorerationale
    Product details

Data path for every feature

  1. Your interface

    Forms and components you own

  2. Your backend

    Tenant rules · API key · retention flag

  3. HireLayer API

    One request, structured JSON back

  4. Your database

    Employee, candidate and job records

The browser never holds the key:POST/api/v1/…is only called from your server.

How it fits

A capability layer behind your own endpoints

Your frontend never talks to HireLayer. Your backend adds tenant context, calls the endpoint and stores the result in your own entities.

  1. Your system

    Step 1, your system: A user acts in your product

    Uploads a CV, pastes a job description or types a skill, in a form you designed.

  2. Your system

    Step 2, your system: Your backend applies tenant rules

    Checks permissions, reads the API key from server config and decides whether to set do_not_store_data for this tenant.

  3. HireLayer

    Step 3, HireLayer API: The relevant API answers

    Parsing, criteria extraction, skill matching, matching or ranking: each is one JSON or multipart request.

    POST /api/v3/parser · /api/v1/…

    • request_id
    • structured JSON
  4. Your system

    Step 4, your system: Map into your entities

    Store fields on your employee, candidate or job objects. Keep request_id for support tickets.

  5. Your system

    Step 5, your system: Render in your design system

    Show results as editable suggestions, so users confirm before anything is saved.

Every endpoint is documented with request fields, limits and error codes.

Browse the API reference

Technical example

A “draft requirements” endpoint in your backend

A route handler your job editor calls. The API key stays on your server and the result is saved as a draft the hiring manager edits.

job_text
The only accepted body field; anything else returns 400.
label · rationale
Generated in French in the current version.
id
crit_1, crit_2… can be sent unchanged to Match.
Request · TypeScript/api/v1/jobs/extract-criteria
// POST /api/jobs/:id/draft-requirements, in your backend
export async function POST(req: Request, { params }: Ctx) {
  const tenant = await requireTenant(req) // your auth
  const job = await jobs.find(tenant.id, params.id)

  const res = await fetch(
    'https://onlineresumeparser.com/api/v1/jobs/extract-criteria',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-Key': process.env.HIRELAYER_API_KEY!,
      },
      body: JSON.stringify({ job_text: job.description }),
    }
  )
  const { matching_criteria } = await res.json()

  // Saved as a draft: weights are edited before publishing
  await jobs.saveDraftCriteria(tenant.id, job.id, matching_criteria)
  return Response.json(matching_criteria)
}
Response · abridged
{
  "matching_criteria": [
    {
      "id": "crit_1",
      "label": "Gestion de la paie multi-entités",
      "weight": 3,
      "is_mandatory": true,
      "rationale": "L'annonce exige explicitement cette expérience."
    },
    {
      "id": "crit_2",
      "label": "Maîtrise d'un SIRH",
      "weight": 2,
      "is_mandatory": false,
      "rationale": "Présenté comme un atout dans l'annonce."
    }
  ]
}

Outcomes

What changes for your product team

  • Features, not research projects

    Each capability is an HTTP call your backend team can wire in, test and release behind a feature flag.

  • Your brand from end to end

    Users never see a HireLayer screen. Results arrive as JSON you render with your own components.

  • Retention decided per tenant

    Choose request by request whether parsed data may be retained, to match each customer contract.

  • One unit of cost

    Every successful call is one credit from a single balance, whichever of the five APIs you use.

APIs used

The HireLayer APIs behind this workflow

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

Compare all products

FAQ

HR software & SaaS: frequently asked questions

Can we offer these features under our own brand?

Yes. HireLayer is API-only: there is no widget or HireLayer screen in your product. Your backend calls the API and your interface renders the result.

Can our frontend call the API directly?

Keep the API key on your server. Expose your own endpoint to the frontend, apply tenant permissions there, then call HireLayer.

How do we expose a no-retention option in our tenant settings?

Store the choice in each tenant’s configuration and have your backend add do_not_store_data, set to true, to that tenant’s parsing calls. Your product still receives the parsed result and renders it under your brand as usual.

Which language are generated texts written in?

CV fields keep the values found in the document. Job criteria labels and rationales, and matching explanations, are generated in French in the current version. Plan your UI copy around them, or translate on your side.

How is usage billed when we serve many customers?

All calls draw from one credit balance: one successful call is one credit, whichever API it is. Log request_id with the tenant on your side to allocate usage per customer.

Prototype one feature this sprint

Start with the endpoint behind your most requested feature, then add the others on the same key. The free plan includes 50 credits a month, shared by all five APIs.