HireLayer logoHireLayer

For sourcing and talent search products

One skill vocabulary for every profile your users source

Profiles reach your product from job boards, referrals, CV databases and uploads, each worded differently. HireLayer parses attached CVs, maps skills and recruiter queries to one catalog, and ranks the longlist a recruiter is about to read.

Get your free API keySkills API docs

Built with

A sourcing search screen. The recruiter's query 'react dev, k8s, postgres' is normalized to the catalog terms React, Kubernetes and PostgreSQL. Below, a longlist of three candidates from different sources is ranked with scores and short rationales.

The problem

Why sourced profiles are hard to search

Your product is good at finding people. The trouble starts when a recruiter tries to compare what was found.

  1. 01

    Every source words skills differently

    “K8s”, “Kubernetes admin” and “container orchestration” overlap. Keyword search treats them as unrelated.

  2. 02

    Recruiter queries are free text too

    A query typed between two calls rarely matches the labels stored on profiles.

  3. 03

    Attached CVs stay unread

    The most detailed information sits in PDFs that nobody opens until a candidate is already shortlisted.

  4. 04

    Longlists have no reading order

    A search returns dozens of plausible profiles; the recruiter needs to know where to start.

Query normalization

What a recruiter types, and what your search runs

Each term goes through /skills/match and comes back as ranked catalog entries with a similarity score. Your product picks the threshold. Example values below are illustrative.

Recruiter types

Your backend sends

POST /api/v1/skills/match
{ "skill": "ReactJS", "top_k": 3 }

Matches at or above the threshold are stored automatically; the others are suggested to the recruiter.

Catalog matches

  1. 1React

    Engineering · Frontend

    Stored
    0.94

  2. 2React Native

    Engineering · Mobile

    Suggested
    0.78

  3. 3JavaScript

    Engineering · Frontend

    Suggested
    0.71

Illustrative values. Scores depend on the catalog and the query.

How it fits

Enrichment after discovery

Discovery, provenance and outreach stay in your product. HireLayer works on profiles you have already captured, and does not source candidates itself.

  1. Your system

    Step 1, your system: A profile is captured

    From any channel your product supports, with or without an attached CV.

  2. HireLayer

    Step 2, HireLayer API: Parse the CV, if there is one

    Adds work history, education, languages and typed skills to the record.

    POST /api/v3/parser

    • work_experiences[]
    • skills[]
  3. HireLayer

    Step 3, HireLayer API: Normalize profile skills in batch

    Up to 100 skill strings per request. Keep the original label for display and the catalog term for search.

    POST /api/v1/skills/match

    • results[].skill
    • similarity_score
  4. HireLayer

    Step 4, HireLayer API: Normalize the recruiter’s query

    Map what the recruiter typed to catalog terms before your search engine runs.

    POST /api/v1/skills/match

  5. HireLayer

    Step 5, HireLayer API: Rank the longlist

    Send the role description and the 10 profiles the recruiter will read first.

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

    • rankings[]
  6. Your system

    Step 6, your system: The recruiter reaches out

    Outreach, sequences and consent stay in your product.

The skills catalog is browsable, with domains and subcategories for your filters.

See the Skills API docs

Technical example

Normalize a profile’s skills in one batch

A Python sketch for an enrichment worker. One request handles up to 100 skills and counts as one credit.

skills
1 to 100 values; send skill instead for a single query.
results[].success
Per-input status, so one bad value never fails the batch.
similarity_score
Illustrative here; your product sets the acceptance threshold.
HireLayer Skills docsAbout HireLayer Skills
Request · Python/api/v1/skills/match
import requests

resp = requests.post(
    "https://onlineresumeparser.com/api/v1/skills/match",
    headers={"X-API-Key": API_KEY},
    json={"skills": ["ReactJS", "Postgres", "project mgmt"], "top_k": 1},
)
batch = resp.json()

for item in batch["results"]:
    if not item["success"] or not item["results"]:
        continue
    best = item["results"][0]
    if best["similarity_score"] >= THRESHOLD:  # your choice
        profile.add_skill(
            raw=item["query_skill"],
            canonical=best["skill"],
            domain=best["domain"],
        )
Response · abridged
{
  "total_queries": 3,
  "successful_matches": 3,
  "results": [
    {
      "query_skill": "ReactJS",
      "success": true,
      "results": [
        {
          "rank": 1,
          "skill": "React",
          "similarity_score": 0.93,
          "domain": "Engineering",
          "subcategory": "Frontend"
        }
      ]
    }
  ]
}

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

Outcomes

What recruiters using your product notice

  • Search that survives synonyms

    Queries and profiles meet on catalog terms rather than on spelling.

  • Richer profiles, no manual entry

    Attached CVs become structured fields as soon as they are captured.

  • A reading order for longlists

    Recruiters open the most relevant profiles first, with a rationale for each position.

  • Facets you can group

    Each catalog entry has a domain and subcategory to build skill clusters and filters.

FAQ

Sourcing tools: frequently asked questions

Does HireLayer find candidates?

No. HireLayer does not crawl or source profiles. It structures and compares the profiles your product has already captured, and your product keeps discovery, provenance and outreach.

How do we normalize skills on profiles imported in bulk?

Send each imported profile’s skill strings together in the skills array, up to 100 per call, and keep the original label for display beside the catalog term used by search. One successful call costs one credit, however many skills it carries.

Can recruiters filter search by the same skill vocabulary?

Yes. The catalog endpoint lists every normalized term grouped by domain and subcategory, so your search filters can offer recruiters exactly the terms that sourced profiles are mapped to.

What if a recruiter’s query maps to the wrong skill?

Every match carries a similarity_score and your product decides what to do with it. Strong matches can be applied to the query silently, while weaker ones appear as suggestions the recruiter confirms before the search runs.

How does ranking fit a long list of search results?

Let your search engine produce the longlist, then send the role and the first profiles the recruiter will open, up to 10, to Rank. Positions only compare profiles sent in the same call, so keep a shortlist together in one request.

Send a real recruiter query

Create an account and send your own skill list to /skills/match. One credit covers a batch of up to 100 skills. The free plan includes 50 credits a month, shared by all five APIs.

Get your free API keySkills API docs

Also built on HireLayer

All solutions