API Documentation

Cancels in-flight parse and matching jobs, refunds unprocessed per-page credits (parse + match) via idempotent guards, and marks the pipeline failed with error "Cancelled by user". Completed match results are preserved — only in-flight / queued work is cancelled. The JD analysis credit (10) is not refunded (matches GUI behaviour).

curl -X DELETE https://api.rebee.ai/api/v1/pipeline/$PIPELINE_ID \
  -H "X-API-Key: identifier:secret"

Idempotent: calling DELETE on an already-terminal pipeline returns the current status without side effects.

Re-orders the already-matched candidates using a new set of hiring priorities. Recomputes rankingScore for every completed row, persists it (so the dashboard & Results page both reflect the new ordering), and returns the sorted list. The underlying component scores (finalScore, skillScore, experienceScore, etc.) are NOT recomputed — matching doesn't run again.

Body (application/json)

• textual, technical, experience, leadership, industry, education (integers)
• enabled: { leadership, industry, education } booleans. A slot with enabled: false is treated as 0.
• The effective priorities must sum to 100 (±1).

curl -X POST https://api.rebee.ai/api/v1/jd/$JD_ID/ranking \
  -H "X-API-Key: identifier:secret" \
  -H "Content-Type: application/json" \
  -d '{
    "textual":    25,
    "technical":  30,
    "experience": 30,
    "leadership": 15,
    "industry":    0,
    "education":   0,
    "enabled": { "leadership": true, "industry": false, "education": false }
  }'

Returns { data: [...sorted candidates], priorities: {...} }. Each candidate carries rankingScore, scores, and matchingWeights.

Returns all completed match rows for this JD, sorted by rankingScore descending. Includes every candidate's component scores and the priority breakdown that produced the current rank. Free to call — no credits deducted.

Tip: pipe to jq to slice the top N candidates locally. The API returns them all; you filter client-side.

# Fetch and keep only the top 5
N=5
curl -s -H "X-API-Key: identifier:secret" \
  https://api.rebee.ai/api/v1/jd/$JD_ID/matching/results \
  | jq ".data | sort_by(-.rankingScore) | .[:$N] | map({
      rank: .rankingScore,
      name: .fileName,
      processId: .processId,
      scores: .scores,
      rankingBreakdown: .rankingBreakdown,
      matchingWeights: .matchingWeights
    })"

Per-candidate shape

{
  "processId": "proc_...",
  "fileName": "Vaibhav Sharma",
  "rankingScore": 65.5,  // 0-100 priority-weighted
  "scores": {
    "finalScore": 0.82,       // semantic + keyword
    "semanticScore": 0.80,
    "skillScore": 0.88,       // technical skills
    "leadershipScore": 0.60,  // soft skills
    "experienceScore": 0.75,
    "educationScore": 0.30,
    "industryScore": 0.20
  },
  "rankingBreakdown": {
    "textual": 20.50,
    "technical": 26.40,
    "experience": 22.50,
    "leadership": 9.00,
    "industry": 0.00,
    "education": 0.00
  },
  "matchingWeights": { "semantics": 60, "keyword": 40 },
  "phase3": { ... },      // detailed analysis
  "phase4": { ... },      // strengths/gaps
  "softSkillCoverage": { ... }
}

Unlike ranking (which only re-sorts), this actually re-runs matching for every candidate with new semantic-vs-keyword weights. All previous match results for this JD are cancelled and a fresh matching run is queued.

curl -X PUT https://api.rebee.ai/api/v1/jd/$JD_ID/weights \
  -H "X-API-Key: identifier:secret" \
  -H "Content-Type: application/json" \
  -d '{ "semantics": 70, "keyword": 30 }'

After this call the JD's matchingStatus becomes in_progress. Poll GET /jd/{jdId}/matching/status (or the pipeline status endpoint) until the new run finishes.

Poll match progress when you only have a jdId (e.g. after a PUT /weights re-match, or when tracking a JD that wasn't created via /pipeline/match). Returns counters + per-resume status.

curl -s -H "X-API-Key: identifier:secret" \
  https://api.rebee.ai/api/v1/jd/$JD_ID/matching/status | jq

Response: { data: { total, completed, processing, failed, pending, canProceed, resumes: [...] } }

Enqueues every parsed resume in the session that doesn't yet have a match result. Safe to call any number of times — it only queues gaps. Useful when a matching worker was restarted or when a resume slipped through. Does not deduct credits (credits were already reserved at parse time).

curl -X POST https://api.rebee.ai/api/v1/jd/$JD_ID/matching/start \
  -H "X-API-Key: identifier:secret"

Cancels every in-flight BullMQ match job for the JD and wipes non-completed match rows. Refunds match credits via the idempotent guard (completed rows are preserved). Does NOT touch the resume session — parsed resumes stay linked and can be re-matched with /matching/start or /weights.

curl -X DELETE https://api.rebee.ai/api/v1/jd/$JD_ID/matching \
  -H "X-API-Key: identifier:secret"

Cancels one resume's match (by its processId) and removes its match-result row. Match credits for that row are refunded.

curl -X DELETE https://api.rebee.ai/api/v1/jd/$JD_ID/matching/$PROCESS_ID \
  -H "X-API-Key: identifier:secret"

The matching pipeline serializes across users (one user's matching jobs run at a time). If you're waiting, this endpoint tells you your position and who's currently holding the lock. Other user IDs are masked for privacy.

curl -s -H "X-API-Key: identifier:secret" \
  https://api.rebee.ai/api/v1/matching/queue-position | jq

Response: { holder: { userId: masked, isYou, acquiredAt }, you: { isHolder, position }, ahead, total }

Same shape as /matching/queue-position but for the standalone parser lock (one user parses resumes through the VM at a time, with a quota of 5 parses per hold before fair-sharing to the next waiter).

curl -s -H "X-API-Key: identifier:secret" \
  https://api.rebee.ai/api/v1/resumes/parser-queue-position | jq

Useful when you've lost a pipelineJobId or want to jump straight to per-JD endpoints. Each item includes jdId, roles, candidate count, matching status, and top-scoring candidate percent.

curl -s -H "X-API-Key: identifier:secret" \
  https://api.rebee.ai/api/v1/jd-classifier \
  | jq '.data | map({jdId, roles, matchingStatus, candidateCount, topScore, createdAt})'

Returns everything stored on the JD: classification result, roles, user skills, soft skills, experience tiers, priority companies/universities/domains, matchingWeights, hiringPriorities, credit tracking fields, and more.

curl -s -H "X-API-Key: identifier:secret" \
  https://api.rebee.ai/api/v1/jd-classifier/$JD_ID | jq

Persists the priority weights onto the JD so later POST /ranking calls can use them as defaults. Does not re-rank existing results and does not charge credits. Use this if you want to save priorities for later without re-running ranking (which charges 0.05/resume).

curl -X PUT https://api.rebee.ai/api/v1/jd/$JD_ID/priorities \
  -H "X-API-Key: identifier:secret" \
  -H "Content-Type: application/json" \
  -d '{
    "textual":    25,
    "technical":  30,
    "experience": 30,
    "leadership": 15,
    "industry":    0,
    "education":   0,
    "enabled": { "leadership": true, "industry": false, "education": false }
  }'

Avoids re-parsing. Takes a list of processIds from resumes you've previously parsed (via /resumes or an earlier JD), links them to this JD, and queues matching. Only match credits charged (pages × 1.5) — parse was already paid.

curl -X POST https://api.rebee.ai/api/v1/jd/$JD_ID/resumes/existing \
  -H "X-API-Key: identifier:secret" \
  -H "Content-Type: application/json" \
  -d '{ "processIds": ["proc_abc123", "proc_def456"] }'

Response: { linked: [...], alreadyLinked: [...], invalid: [...] }. Returns 402 if insufficient match credits (atomic — no partial charge).

HTTP doesn't have a native concept of folders — your client enumerates the files and attaches each as a multipart part. Each POST call accepts up to 100 resume PDFs. For larger batches, set auto_start=false on the first call, add more batches via /pipeline/{id}/resumes, then trigger matching with /pipeline/{id}/start.

All resumes fit in one call (≤ 100 PDFs)

# Uses shell glob; auto_start=true (default) runs the pipeline end-to-end
curl -X POST https://api.rebee.ai/api/v1/pipeline/match \
  -H "X-API-Key: identifier:secret" \
  -F "jd_text=$(cat jd.txt)" \
  $(for f in ./resumes/*.pdf; do echo -F resumes=@"$f"; done)

More than 100 PDFs — multi-batch

# 1. First 100 resumes + opt out of auto-start
PID=$(curl -s -X POST https://api.rebee.ai/api/v1/pipeline/match \
  -H "X-API-Key: identifier:secret" \
  -F "auto_start=false" \
  -F "jd_text=$(cat jd.txt)" \
  $(for f in $(ls ./resumes/*.pdf | head -100); do echo -F resumes=@"$f"; done) \
  | jq -r .data.pipelineJobId)

# 2. Wait until status is awaiting_start
while true; do
  S=$(curl -s -H "X-API-Key: identifier:secret" https://api.rebee.ai/api/v1/pipeline/$PID | jq -r .data.status)
  [ "$S" = "awaiting_start" ] && break; sleep 2
done

# 3. Upload remaining batches of up to 100 each
i=0
ls ./resumes/*.pdf | tail -n +101 | split -l 100 - batch_
for batch in batch_*; do
  curl -X POST https://api.rebee.ai/api/v1/pipeline/$PID/resumes \
    -H "X-API-Key: identifier:secret" \
    $(for f in $(cat $batch); do echo -F resumes=@"$f"; done)
done

# 4. Trigger matching
curl -X POST https://api.rebee.ai/api/v1/pipeline/$PID/start \
  -H "X-API-Key: identifier:secret"