Skip to content

Workday integration · Recruiting web service (SOAP)

AI screening and normalized skills for Workday Recruiting

Workday Recruiting already reads resumes into the candidate profile, but its parsing leaves skills and languages to the candidate. HireLayer scores each application against the requisition, with an explanation per criterion, and fills those sections through the Recruiting web service.

Workday API
Recruiting web service (SOAP), v47.0
Trigger
Get_Candidates on a schedule
Write-back
Job application attachment, resume data, tags
Cost
2 credits per application
Workday + HireLayer
  1. 1A candidate appliesWorkdayYour integration finds new applications with Get_Candidates, filtered on the requisition and Applied_From. The resume comes back as base64 in Resume_Attachment_Data.
  2. 2Parse the resumeHireLayerThe decoded file goes to HireLayer Resume Scorer, which first parses it into experience, education, languages and skills.
  3. 3Score against the requisitionHireLayerResume Scorer compares the resume with criteria extracted once from the job posting and returns a score and an explanation per criterion.
  4. 4Write back to WorkdayWorkdayPut_Candidate_Attachment adds the report to the job application. Put_Candidate can add skills, languages and a candidate tag.

What recruiting teams do with HireLayer and Workday

  • Triage high-volume requisitions

    Every application gets a score from 0 to 1 and the list of mandatory criteria it meets. Recruiters open the strongest matches first insted of working in arrival order.

  • Explain the shortlist

    The report attached to the job application lists each criterion with its status and the evidance found in the resume, so hiring managers see why a candidate is ahead.

  • Fill skills and languages

    Write HireLayer’s skills and languages into Skill_Data and Language_Data, one normalized name per skill, so recruiters can search candidates by skil across requisitions.

  • Rediscover past applicants

    Pull earlier candidates with Get_Candidates, by tag, stage or requisition, and rank them against a new requisition with HireLayer Resume Scorer and its precise_ranking option.

Connect Workday Recruiting to HireLayer

Your Workday integration team runs this as a small service outside Workday, such as a serverless function or an iPaaS flow, or as a Workday Studio integration. It works in your own tenant; no Workday partner program is needed.

  1. 1

    Create an integration system user

    Your Workday security administrator creates an integration system user and an integration system security group with the recruiting domains the service uses, including Candidate Data: Attachments to add files. The service signs each SOAP request with a WS-Security username token.

  2. 2

    Extract criteria once per requisition

    When a requisition opens, send its job posting to HireLayer Job Criteria Extractor with the requisition ID as job_id. HireLayer stores it with its criteria, for free, and every applicant is then scored on the same list.

  3. 3

    Find new applications

    Call Get_Candidates on a schedule with Job_Requisition_Reference and Applied_From set to your last run. Results are paged (Count up to 999) and include resume files unless Exclude_All_Attachments is set. Teams that prefer push can subscribe an endpoint to business process events with Workday’s Notification web service.

  4. 4

    Parse, score and write back

    Decode File_Content, send it to Resume Scorer, which parses and scores the resume in one call, then call Put_Candidate_Attachment with the Job_Application_Reference and an active recruiting document category. Use Put_Candidate for skills, languages or a candidate tag.

Where HireLayer results go in Workday

Put_Candidate writes resume data in Job_Application_Data › Resume_Data, next to the Job_Applied_To_Data it requires. What it accepts depends on your job application template and its “Enforce Required in Web Service” settings: test in your implementation tenant first. Resume Scorer keeps the parsed resume: read its fields for free with GET /api/v4/resumes/{application_id}.

HireLayer fieldWorkday Recruiting (SOAP)Note
score + summary + criteria[]Put_Candidate_Attachment › Additional_Attachment_Data (File_Content, Comment)Needs an active recruiting Document_Category_Reference
score ≥ your thresholdCandidate_Tag_Reference (Put_Candidate)The tag must already exist and be active
resume.skills[].skill_titleResume_Data › Skill_Data › Skill_NameOr Skill_Reference to a skill in your tenant
resume.languages[].languageResume_Data › Language_DataInactive languages are rejected
resume.work_experiences[]Resume_Data › Experience_Data (Company_Name, Title, Start_Year, Currently_Work_Here, Description)Split dates into month and year
resume.educations[]Resume_Data › Education_Data (School_Name, Degree_Reference)Degrees reference your tenant’s list
resume.info_candidate.email, phone_numberContact_Data (Email_Address, Phone_Number)A phone also needs a device type and country code

Score an application and attach the report

A TypeScript outline for one application read with Get_Candidates: it parses and scores the resume in one Resume Scorer call, against the requisition stored with its criteria, and adds a report to the job application with Put_Candidate_Attachment. Add paging and retries.

workday-screening.tstypescript
const { WD_HOST, WD_TENANT, WD_ISU_USER, WD_ISU_PASSWORD, WD_DOC_CATEGORY } = process.env
const WORKDAY = `https://${WD_HOST}/ccx/service/${WD_TENANT}/Recruiting/v47.0`
const HIRELAYER = 'https://hirelayer.co'
const apiKey = { 'X-API-Key': process.env.HIRELAYER_API_KEY! }

// Recruiting web service call, signed as the integration system user
async function workday(body: string): Promise<string> {
  const res = await fetch(WORKDAY, {
    method: 'POST',
    headers: { 'Content-Type': 'text/xml; charset=utf-8' },
    body: `<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/"
  xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
  xmlns:wd="urn:com.workday/bsvc">
  <env:Header><wsse:Security><wsse:UsernameToken>
    <wsse:Username>${WD_ISU_USER}</wsse:Username>
    <wsse:Password>${WD_ISU_PASSWORD}</wsse:Password>
  </wsse:UsernameToken></wsse:Security></env:Header>
  <env:Body>${body}</env:Body></env:Envelope>`,
  })
  if (!res.ok) throw new Error(`Workday ${res.status}: ${await res.text()}`)
  return res.text()
}

// app: one job application read with Get_Candidates (Resume_Attachment_Data)
export async function screen(app: Record<string, string>) {
  // Parse and score in one call (about a minute), against the requisition
  // stored with its criteria by POST /api/v4/jobs/extract-criteria
  const form = new FormData()
  form.append('request', JSON.stringify({
    job: { job_id: app.requisitionId },
    resumes: [{ file: 'resume', application_id: app.jobApplicationId }],
  }))
  const file = new Blob([Buffer.from(app.fileContent, 'base64')]) // base64 in Workday
  form.append('resume', file, app.filename)
  const response = await fetch(`${HIRELAYER}/api/v4/resumes/score`, {
    method: 'POST', headers: apiKey, body: form, signal: AbortSignal.timeout(150_000),
  })
  // Errors come as { error: { code, message } } (no credits, unknown job): skip.
  if (!response.ok) return
  const { scores: [result] } = await response.json()
  // An unreadable file fails only its own score, unbilled.
  if (result.evaluation_status !== 'completed') return

  const report = Buffer.from(`Score: ${result.score}\n\n${result.summary}`).toString('base64')
  await workday(`<wd:Put_Candidate_Attachment_Request wd:version="v47.0">
  <wd:Job_Application_Attachment_Data>
    <wd:Job_Application_Reference>
      <wd:ID wd:type="Job_Application_ID">${app.jobApplicationId}</wd:ID>
    </wd:Job_Application_Reference>
    <wd:Additional_Attachment_Data>
      <wd:Filename>hirelayer-${Date.now()}.txt</wd:Filename>
      <wd:File_Content>${report}</wd:File_Content>
      <wd:Comment>HireLayer score ${result.score}</wd:Comment>
      <wd:Document_Category_Reference>
        <wd:ID wd:type="Document_Category_ID">${WD_DOC_CATEGORY}</wd:ID>
      </wd:Document_Category_Reference>
    </wd:Additional_Attachment_Data>
  </wd:Job_Application_Attachment_Data>
</wd:Put_Candidate_Attachment_Request>`)
}

Good to know

  • Not a Workday Marketplace app

    HireLayer is not listed on Workday Marketplace. You connect it with your own integration system user, or ask us to build the connector with your integration team.

  • Your tenant decides what is accepted

    Job application attachments need a document category that is active and belongs to a recruiting document category group, and file names must be unique per application. Tags and languages must be active.

  • Plan for parsing time

    Parsing and scoring take about a minute. Run them in a background job, or add a webhook_url to the Resume Scorer call: HireLayer answers 202 and posts the signed result to your endpoint.

  • Results in the job’s language

    Criteria labels, summaries and explanations follow the job posting’s language when it is English, French, German, Spanish or Portuguese, and are in English otherwise; scores and field names do not change. HireLayer processes data in the EU, and do_not_store_data keeps no copy of the file.

HireLayer and Workday: questions

Does HireLayer integrate with Workday?

Yes, through Workday’s Recruiting web service: your service reads new applications, calls HireLayer, and writes the score and skills back to the job application. HireLayer has no Workday Marketplace app; we can build the connector with your integration team on request.

Which resume parser does Workday use?

Workday’s documentation names no third-party resume parsing engine (checked on November 18, 2026). Its resume parsing creates a prospect or job application and fills fields from the resume for the recruiter to review, but it does not fill the Languages or Skills fields. HireLayer adds those, plus a score against the requisition with an explanation per criterion.

Which Workday access does the integration need?

An integration system user in an integration system security group, created by your Workday security administrator, with the recruiting domains for reading candidates and adding attachments. No Workday partner program is needed for your own tenant.

How many credits does one application use?

Two: one to parse the resume and one to score it, in the same Resume Scorer call. Criteria are extracted once per requisition, for free, then reused for every applicant. Normalizing skills separately costs one credit per call.

Workday misread my resume when I applied. Can HireLayer fix it?

No. This page is for employers that run Workday Recruiting. When you apply, the employer’s Workday site reads your resume and HireLayer has no access to it: check the fields Workday prefilled and correct them before you submit.

Connect Workday to HireLayer today

The Free plan includes 50 credits a month, no card required. Parsing a resume costs one credit, scoring one per resume evaluated, and extracting job criteria is free.