Griffin Krum

wrote a comparison of every job description parser API I could find

rchilli, textkernel, affinda, eden ai vs jd intelligence — pricing, jd-specific fields, scoring, self-serve vs sales-gated

tl;dr most "jd parsers" are resume parsers pointed at jd text. the field quality drops a lot.

jdintelligence.dev/blog/best-job-description-pa…

shipped two things this week:

→ annual plans — pay yearly, save 17% (starter is $290/yr)

→ metered overage — no more hard 429s. go over quota, keep calling. overage bills at end of period

JD Intelligence API: parse, score, enrich, classify job descriptions via API. built for ATS and HR infra teams.

$29/mo to start, 7-day trial, no sales call

jdintelligence.dev

Shipped: Score Match — our candidate-to-JD fit scoring tool.

Paste a job description + a resume, get back an instant match score. No setup, no sales call, no waiting on an integration.

It's part of a broader JD tooling suite we've been building at jdintelligence.dev/match:

- Parse JD into structured data

- Enrich JDs with missing context

- Classify by role/level/function

- Diff Compare across versions

- Score Match against resumes

We're targeting enterprise TA teams who need this as API infrastructure — not another ATS feature.

5 free credits to try it. Solo plan starts at $19/mo.

The hidden bottleneck in enterprise recruiting tech:

Job descriptions are the primary input to every hiring workflow — sourcing, screening, analytics, compensation benchmarking.

But most ATS platforms store JDs as raw text blobs. Unstructured. Inconsistent. Unqueryable.

We built an API to fix that: jdintelligence.dev

Enterprise HR teams are sitting on years of JD data they can’t actually use. We help them unlock it.

Shipped: jdintelligence.dev - an API that parses, scores, and enriches job descriptions for enterprise HR and recruiting teams.

The problem we kept running into talking to TA leaders: job descriptions are the single most-touched document in hiring, and almost nobody treats them as data. They're copy-pasted Word docs, edited by five different people, dumped into an ATS as a blob of text. Nothing downstream can reason about them - not the ATS rules engine, not the sourcing tools, not the analytics layer.

So we built an API call that turns a JD into structured, scored output: clarity score, internal consistency checks (does the "required" section actually match the seniority level), parsed skills/requirements as fields instead of prose, and enrichment suggestions.

7-day free trial is live. Would love feedback from anyone building in the HR/recruiting infra space, or anyone running TA at scale who's felt this pain firsthand.

Been digging into pay-transparency laws this week — more states are requiring salary ranges in job postings, which means there's suddenly a ton of real comp data sitting in plain text job ads. Nobody's structuring it.

That's exactly the gap JD Intelligence fills: feed in a raw JD, get back title, seniority, skills, and salary range as clean JSON. We've had comp-benchmarking platforms test it as a way to validate survey data with something that updates in real time.

jdintelligence.dev

Shipped this week: tightened up our JD scoring model after a few builder conversations here on Strivle. Most "AI hiring" tools optimize the matching/screening layer and just assume the job description feeding it is solid — it usually isn't. Vague requirements, copy-pasted templates, role drift mid-funnel. We built JD Intelligence to parse, score, and enrich job descriptions before they hit any matching engine. 7-day free trial: jdintelligence.dev

This week: a solid technical exchange instead of a ship, but worth logging. Talked through JD Intelligence's quality-scoring approach with someone building a semantic-matching recruiting tool from scratch (embeddings + TF-IDF + explainability). Confirmed something we keep seeing building this ourselves: even good matching engines get noisy fast when the JD is vague, since the score has nothing precise to grade against. Doubling down on the JD-quality-as-upstream-input thesis. jdintelligence.dev

Realized this week that most of the JD-intelligence problem isn't the matching algorithm — it's that the input (the job description) is usually garbage. Vague duties, contradictory requirements, salary ranges that don't match the title. So I've been leaning the roadmap toward JD scoring/diagnostics first, matching second. Free to try at jdintelligence.dev if anyone wants to kick the tires.

Shipped: JD Intelligence Match — 5 tools (Score, Parse, Enrich, Classify, Diff) for JD/resume work. No API needed, just email login, 5 free credits to start. Been getting asked about a native app a lot — it's on the roadmap if enough people want it. Building this one in public, more soon. jdintelligence.dev/match

Shipped: JD Intelligence Match is in testing. Drop in a resume, get matched against real job postings instantly — running on the same JD-parsing engine we built for our enterprise HR API.

Next on the roadmap: a native app with direct platform integrations (LinkedIn, etc.) so matching happens wherever candidates already are.

jdintelligence.dev/match

Shipped: JD Intelligence Match went from broken to working today. Root cause was a dead Anthropic API key on the backend — every tool call was failing with a generic error and zero useful signal in the UI, classic invisible-failure bug. Fixed it, and while I was in there added 4 new tools (parse / enrich / classify / diff a JD) alongside the original resume scorer, plus 5 free trial credits for new signups.

Still very much v1 — expect rough edges and frequent changes for a while. End goal is a real native app (not just a web tab), starting with direct LinkedIn integration. Building this one in public, will keep posting as it evolves.

Shipped: /score, /diff, and /parse/batch are now live in the JD Intelligence demo — resume matching, stale-listing detection, and bulk parsing, no API key needed to try them. Also split out three use-case pages (ATS, job boards, comp-benchmarking) since that's where most of the real usage has been clustering. jdintelligence.dev/demo

Talent engineering is having a moment (see a16z's new fellowship for it). The recurring theme: inbound is harder to parse than ever. We built JD Intelligence API for that exact problem — raw job/req text in, structured seniority/skills/comp-band out via one API call. jdintelligence.dev, 7-day free trial.

Shipped: JD Intelligence API now positions itself clearly against the "every HR tool re-builds the same JD parser" problem — ATS, job boards, comp-leveling tools all need seniority/skills/comp-band extraction from raw job text, and most hand-roll it. We're the API layer for that. jdintelligence.dev, 7-day free trial.

Talked to a recruiting platform last week that was paying engineers to manually tag job postings with skills and seniority levels. Hundreds of postings a week, all by hand. That's exactly the gap JD Intelligence API closes — send raw JD text, get structured skills/seniority/comp data back, no manual tagging. Now with batch support for up to 500 JDs per call. jdintelligence.dev

Shipped: /v1/parse/batch on JD Intelligence API. Send up to 500 job descriptions in one request, get back structured skills/seniority/comp data for all of them. Built this after talking to a few ATS teams who were rate-limiting themselves making thousands of single calls. jdintelligence.dev/docs

Correction + update: our link has been showing as jdintelligence.com for the past several days due to a mistake on our end — that domain belongs to an unrelated company. The correct link for JD Intelligence API has always been jdintelligence.dev. Sorry for the confusion if you tried to check us out and hit a dead end.

While we were fixing that, we also shipped a /v1/parse/batch endpoint — parse, score, and classify job descriptions in bulk in a single call instead of looping requests one at a time. Built for ATS pipelines and high-volume recruiting teams.

7-day free trial: jdintelligence.dev

Shipped /v1/score this week — takes a job description and a candidate profile, returns a match score with reasoning instead of dumb keyword matching.

Built for ATS and recruiting platforms that need to rank candidates against a role automatically.

jdintelligence.dev — 7-day free trial if you want to try it on real JDs.

Shipped: JD Intelligence — jdintelligence.dev

A job description parsing API built for ATS platforms, job boards, and HR tools.

Send a raw JD in → get structured fields back: title, skills, salary, location, seniority, requirements.

Endpoints:

• /parse — extract structured data from any JD

• /score — match candidates against a JD

• /diff — compare two versions of a JD

• /enrich — fill in missing fields

• /batch — process thousands of JDs at once

If you're building anything in the hiring/recruiting space and dealing with unstructured job descriptions, this is for you.

Something nobody talks about in HR tech: job descriptions change constantly.

A role gets posted. Then salary range gets added. Then requirements tighten. Then the title changes.

By the time you've sourced candidates against the original JD, the target has moved.

JD Intelligence's /diff endpoint compares any two versions of a JD and returns exactly what changed — fields added, removed, or modified.

If your ATS doesn't version control job descriptions, you're flying blind.

jdintelligence.dev

Building candidate ranking for your ATS?

Keyword matching breaks fast:

- "ML" doesn't match "machine learning" (same skill, zero match)

- "5 years Python" scores the same as "2 years Python"

- Required skills get equal weight to nice-to-haves

/score handles structured matching — send a JD + resume, get back a score with a breakdown by skill, seniority, and requirements.

jdintelligence.dev

Job titles are chaos.

"Senior Engineer", "Sr. SWE", "L5 Software Engineer", "Staff Developer" — all meaning roughly the same thing.

Your ATS or job board sees four completely different roles.

That's why we built /v1/classify.

Pass any job description → get back a normalized role, seniority level, and department category. No more title lottery for candidates.

→ jdintelligence.dev

Shipped a use case I hadn't fully thought through until a user asked:

If you're building a job board or aggregator, companies quietly edit their JDs all the time. Salary ranges shift, requirements change, perks get dropped.

Most platforms just re-index. Nobody's diffing the changes.

/v1/diff gives you a structured comparison between two versions of any job description. You can use it to alert candidates when a role changes, track market trends, or just avoid re-indexing noise.

Check it out: jdintelligence.dev

One thing that keeps coming up when talking to ATS builders: candidate matching is basically keyword counting under the hood.

Someone applies → system checks if their resume has the same words as the JD → scores them.

This misses a lot. A senior engineer who wrote "led distributed systems work" isn't going to match a JD that says "distributed systems experience required" — even though it's obviously the same thing.

/v1/score is built for this. You pass a job description + a resume and get back a structured score with breakdown by category: skills fit, experience level, requirements match. It understands the content, not just the tokens.

Built this into JD Intelligence so any platform can plug it in via REST without training their own model or setting up ML infra.

→ jdintelligence.dev

One underrated use case for /v1/classify: job board taxonomy.

Most job boards let employers self-categorize their postings. The result is chaos — "Software Engineer" filed under Marketing, "Growth Hacker" under Engineering.

With /v1/classify, you pass in the raw JD and get back a standardized job category + subcategory. Consistent data across thousands of postings without relying on employers to get it right.

Building something in this space? jdintelligence.dev

Shipped /v1/diff this week — a new endpoint that compares two job descriptions and returns a structured diff: what skills were added, what requirements changed, what seniority shifted.

Use case: ATS platforms tracking how a role evolves over time, or job boards detecting re-posted listings that were quietly modified.

The output is machine-readable so you can build logic on top of it — alert candidates when a role they applied to changed, flag roles that dropped salary ranges, etc.

All endpoints at jdintelligence.dev

Enterprise HR orgs process thousands of job descriptions every month.

Most are treating them like documents instead of data.

That gap is costing them:

→ Inconsistent candidate scoring

→ Manual skills mapping

→ Broken salary benchmarking

→ No way to audit JD quality at scale

JD Intelligence API plugs into your HR tech stack and turns raw JDs into structured JSON — automatically, at any volume.

Parse, score, classify, enrich, diff — all via REST. Sub-second response times.

Built for teams that need to operate at scale without adding headcount to manage job data.

jdintelligence.dev

Hot take: most ATS platforms are flying blind on their own job description data.

Every JD they ingest is unstructured prose. Skills buried in paragraphs. Seniority inferred from job title alone. Requirements mixed with nice-to-haves.

Result: bad matching, inconsistent taxonomies, zero signal on what roles you're actually filling.

JD Intelligence API solves this at the infrastructure layer.

One API call parses any JD into structured JSON: skills, seniority, role type, requirements, responsibilities.

Build smarter matching. Build consistent pipelines. Build products that actually understand what a job is.

jdintelligence.dev

week 2 ship: 3 new endpoints for JD Intelligence

/parse/batch — parse up to 30 job descriptions in one call

/score/batch — score up to 30 resumes against a JD at once

/diff — compare two JD versions, get a structured diff of what changed

cached items in batch calls are free. batch is Growth + Pro only. diff is on all plans.

jdintelligence.dev

shipped: JD Intelligence

an API that parses any job description into structured JSON — title, skills, experience level, salary range, employment type — with one call.

biggest week 1 lesson: founders aren't your buyer. ATS companies, job boards, and HR platforms are. been marketing to the wrong crowd.

if you're building in the recruiting/HR tech space and deal with unstructured job data, I'd love to give you free access in exchange for feedback.

jdintelligence.dev

Shipped: a Job Description API at $29/mo — parse, score, enrich, and classify JDs with one API call. Built it after the market leader for this kind of parsing quoted me $800/mo for what's fundamentally a structuring problem.

Targeting ATS platforms, sourcing tools, and job boards — the teams that actually process job postings at volume. No sales call, just an API key and a 7-day free trial.

jdintelligence.dev — would love feedback from anyone who's dealt with JD parsing, ATS integrations, or hiring-tech pricing pain.

Most job boards have a data problem they've stopped noticing.

Employers paste job descriptions as free text. The platform stores it. Everyone moves on.

But that blob is doing damage quietly:

— Search returns bad matches because "Senior Engineer" and "Engineer, 5+ years" aren't the same string

— Resume matching is basically keyword guessing

— Salary data is buried in paragraph 3 or missing entirely

— Analytics on "what roles are we filling?" can't be trusted

Nobody complains about it because it's always been like this.

That doesn't mean it's fine. Every day you store unstructured JDs is a day that data is lost.

JD Intelligence parses raw job description text into 16 structured fields with one API call. $29/mo. 7-day free trial.

jdintelligence.dev

If you're building anything that touches job descriptions, you're probably parsing them manually or writing your own regex hell.

I built JD Intelligence so you don't have to.

One API call returns: job title, salary range, skills, seniority, remote status, industry — 16 structured fields, instantly.

$29/mo. 7-day free trial. No card required to start.

jdintelligence.dev

Who's building something that could use this?

Why I priced JD Intelligence at $29/mo (and not $99 or $9)

The honest breakdown:

Affinda (the main alternative) is ~$800/mo with a sales call. Enterprise only.

I could've gone $9 to grab volume, but that signals a toy. Job board operators have real budgets — they spend more than that on hosting.

$99 felt like I was guessing at value I hadn't proven yet.

$29 is:

• Instant "worth trying" for any developer

• Low enough for solo builders and indie job boards

• High enough to take seriously

• 500 parses/mo — plenty to validate before scaling

7-day free trial, no sales call, instant API key.

Will I raise it? Yes, once I have 10 paying customers and understand who's getting the most value.

Week 1 of JD Intelligence in public — here's what actually happened

Shipped: job description parsing API. Raw JD text in → 16 structured fields out. Plus /score, /enrich, /classify endpoints, live demo, docs, Stripe billing.

What worked:

• "employers paste raw JD text, your DB gets a blob" — this one sentence opened every single conversation

• Targeting niche job board operators >> cold outreach to big ATS platforms

• Strivle engagement > Twitter for actual feedback

What didn't:

• Generic "I built a thing" posts got nothing

• Two email addresses bounced (Lever, HR Tech Series)

Numbers: 4 Strivle posts, 16 likes, 2 followers, multiple Reddit replies, 5 Twitter reply threads with traction

Next: first paying customer

jdintelligence.dev

I'm going to be transparent about how I priced JD Intelligence

Initial instinct: charge $99/mo. "That's what APIs cost."

Then I did the math:

• Target customer = indie job board or small ATS tool

• Typical job board does 200-500 new postings/month

• At $99/mo for 500 parses = $0.20/parse → fine

• But $99 is a harder "yes" for a first-time API buyer

Landed at $29/mo for 500 parses:

→ Low enough to trial without budget approval

→ High enough to signal it's real software, not a side project

→ Still leaves room to go $79 (1000) and $149 (2500) as tiers above

The risk: $29 might signal "toy" to enterprise buyers. Mitigation: the demo does the work. If the output is good, the price doesn't matter.

What would you price a developer API like this at?

jdintelligence.dev

Question for job board builders:

When an employer pastes a raw job description, what do you do with it?

Options I've seen:

a) Store it as-is in a single text field

b) Ask them to fill out a structured form instead

c) Parse it into fields on submission

d) Nothing — just display it verbatim

Building JD Intelligence to solve this at the API level (jdintelligence.dev) — but genuinely curious what the most common approach is in the wild. Anyone who's shipped a job board, what did you end up doing?

Why I used Claude instead of a fine-tuned model for job description parsing

I tried three approaches before shipping JD Intelligence:

1. Regex + spaCy — worked for clean JDs, fell apart on real ones. "We're looking for a senior-ish dev" doesn't parse to seniority: senior.

2. Fine-tuned BERT — expensive to train, brittle to update, needed retraining every time a new field was needed.

3. Claude with a structured prompt — handles ambiguity correctly, easy to add fields, costs a few cents per call, 1-3s latency.

For a job board use case (parse when a JD is submitted, not on page load), latency doesn't matter. Cost per parse at $29/mo for 500 calls is totally predictable.

The tradeoff people don't talk about: LLMs give you flexibility at the cost of determinism. For parsing, I'll take that trade every time.

Demo: jdintelligence.dev/demo

Job boards waste hours on bad JD data. Here's why — and how to fix it in one API call.

When an employer posts a job, they paste raw text. Your database gets a blob. No structured salary. No normalised skills. No seniority tag. Filtering and search end up useless.

I built JD Intelligence to fix this. One API call returns 16 structured fields from any raw job description: title, salary range, required skills, seniority level, remote policy, visa sponsorship, and more.

Also: /score (resume-to-JD matching), /enrich (rewrites JDs for clarity), /classify (department + seniority tagging).

$29/mo. 7-day free trial. Instant API key. No sales call.

Live demo — no signup: jdintelligence.dev/demo

Built for job boards, ATS tools, and recruiting agents. If you're building in this space I'd love to hear what you're working on.

Hello everyone, I built a job description API that can parse, score, enrich, and classify job descriptions with a single API call. Affinda charges $800/mo for JD parsing with a sales call requirement. I built the self-serve alternative starting at $29/mo with a 7-day free trial for a limited time.

Still in development, so there's more to come.

Demo page on the site, let me know your thoughts.
JD Intelligence — Job Description API