{"id":1387,"date":"2026-06-25T08:02:36","date_gmt":"2026-06-25T08:02:36","guid":{"rendered":"https:\/\/hirium.com\/blog\/?p=1387"},"modified":"2026-06-25T08:02:36","modified_gmt":"2026-06-25T08:02:36","slug":"ai-resume-parser-explained","status":"publish","type":"post","link":"https:\/\/hirium.com\/blog\/ai-resume-parser-explained\/","title":{"rendered":"AI Resume Parser Explained: How It Reads a Resume in Seconds"},"content":{"rendered":"

A single corporate opening pulls in roughly 250 applications, yet a recruiter gives each resume about 7.4 seconds before deciding to keep reading or move on. Run that math across a 20-role pipeline and one recruiter is staring down 5,000 documents\u00a0 most of which will never get a fair second look by a human being.<\/span><\/p>\n

That gap between application volume and human attention is exactly where an <\/span>AI Resume Parser<\/b> earns its place. It does not get tired at resume number 400, it does not skim, and it does not lose the candidate whose strongest qualification was buried on page two. Instead, it reads every document the same way, extracts the same fields every time, and hands recruiters a searchable, filterable database in the time it takes to refill a coffee.<\/span><\/p>\n

According to <\/span>Glassdoor<\/b><\/a>, the average corporate job opening attracts roughly <\/span>250 resumes<\/b>, and only 4\u20136 of those candidates are ever interviewed.<\/span><\/p>\n

This is not a futuristic promise. Modern AI Resume Parsers already convert unstructured CVs into clean records at scale, and benchmark studies put extraction accuracy on standard formats between 94% and 99%. The technology has moved from “nice to have” to load-bearing infrastructure for any team hiring at volume.<\/span><\/p>\n

What most teams never see is the actual machinery, the sequence of steps that turns a PDF full of inconsistent formatting into a row in a candidate database. This guide breaks down that sequence in plain terms: how text gets extracted, how fields get tagged, how skills get mapped, where accuracy comes from, and the specific document types that still trip these systems up. By the end you will understand not just what the technology does, but where to trust it and where to keep a human in the loop.<\/span><\/p>\n

What Is an AI Resume Parser?<\/b><\/h2>\n

An <\/span>AI Resume Parser<\/b><\/a> is software that uses <\/span>natural language processing<\/b> and <\/span>machine learning<\/b> to read an unstructured resume and convert it into structured, machine-readable data\u00a0 name, contact details, work history, education, and skills\u00a0 that an <\/span>applicant tracking system<\/b> can store, search, and rank automatically.<\/span><\/p>\n

In short: it turns a document a human wrote for other humans into a record a database can query in milliseconds.<\/span><\/p>\n

\"Corporate<\/p>\n

The Core Problem: Why Manual Screening Breaks at Volume<\/b><\/h2>\n

The bottleneck in early-stage hiring is rarely sourcing\u00a0 it is triage. When 250 resumes land for one role and a recruiter is juggling 15\u201325 open requisitions, the arithmetic stops working. At 30 to 90 seconds per resume, screening just 500 applications by hand consumes 8 to 25 hours of focused work before a single qualified candidate is contacted.<\/span><\/p>\n

That time pressure produces two expensive failure modes. The first is speed: the average <\/span>time-to-hire<\/b><\/a> sits near 42 days, and every day a role stays open is a day of lost output and a wider window for strong candidates to accept competing offers. The second is the silent attrition of good applicants. Studies of recruiter behavior consistently find that the large majority of resumes never clear the first screen\u00a0 not because the candidates are unqualified, but because there was no time to read carefully.<\/span><\/p>\n

Manual review also bakes in inconsistency. Two recruiters reviewing the same stack apply different mental shortcuts, and the same recruiter applies different standards at 9 a.m. than at hour seven of screening. Skim-reading is where subjective, non-job-related signals\u00a0 a school name, a familiar former employer\u00a0 quietly starts steering decisions.<\/span><\/p>\n

For startups and SMBs the math is harsher still, because hiring volume spikes without a corresponding jump in recruiting headcount. A 12-person company running a hiring sprint can receive the same application load as an enterprise team ten times its size, with no spare capacity to absorb it.<\/span><\/p>\n

There is a hidden cost layer beneath the visible one. Manual data entry\u00a0 copying a name, an email, and a work history from a resume into a system of record\u00a0 is both slow and error-prone, and those typos surface later as duplicate records, broken email sends, and candidates who simply cannot be found again. The longer a team operates without an AI Resume Parser, the more its candidate data degrades into a pile of inconsistent, half-searchable entries. This is the precise problem structured automation was built to solve.<\/span><\/p>\n

How an AI Resume Parser Works, Step by Step<\/b><\/h2>\n

This is the part most explainers skip. A parser is not a single model that “reads” a resume the way a person does; it is a pipeline of distinct stages, each with its own job, its own failure points, and its own accuracy ceiling. Understanding how an AI resume parser works end to end is what lets you judge a vendor’s claims instead of taking them on faith.<\/span><\/p>\n

Step 1\u00a0 Text Extraction and Document Normalization<\/b><\/h3>\n

Before anything can be understood, the raw text has to come off the page. Resumes arrive as PDFs, DOCX files, RTFs, plain text, and occasionally as images, and each format stores text differently. A clean, text-based PDF is straightforward; a scanned resume is effectively a picture, which forces the system to fall back on optical character recognition to reconstruct the words pixel by pixel.<\/span><\/p>\n

This stage also normalizes layout. Multi-column designs, headers, footers, and text boxes scramble the reading order, so the AI Resume Parser has to rebuild the logical sequence of the document\u00a0 figuring out that the “Skills” sidebar on the right belongs with the experience block on the left, not interleaved line by line.<\/span><\/p>\n

Step 2\u00a0 Field Tagging with Named Entity Recognition<\/b><\/h3>\n

Once the text is clean, the AI Resume Parser identifies what each piece of information actually is. Using named entity recognition, it tags spans of text as a person’s name, an email, a phone number, a company, a job title, a date range, or a degree. This is the step that separates true parsing from simple keyword spotting.<\/span><\/p>\n

The advantage of an NLP-driven approach is context. A first-generation keyword parser might miss “Python” if it only appears inside a project description; a modern machine learning model recognizes it because it understands the surrounding verbs and nouns. The same logic lets the AI Resume Parser read “Managed a team of 15 developers” and tag it as quantified leadership experience rather than a loose string of words.<\/span><\/p>\n

Step 3\u00a0 Skill Mapping and Taxonomy Normalization<\/b><\/h3>\n

Raw extracted skills are messy. “Software Eng,” “Sftw. Developer,” and “Engineer” all point to the same role, and a usable system collapses those variants into one standardized entry using a skill taxonomy. The same normalization applies to job titles, certifications, and seniority levels.<\/span><\/p>\n

This is what makes downstream comparison possible. Without skill mapping, a search for “JavaScript developers” misses every candidate who wrote “JS”\u00a0 so the cleanup at this stage directly determines how complete your later candidate searches will be.<\/span><\/p>\n

Step 4\u00a0 Structuring Data for Search and Filtering<\/b><\/h3>\n

Finally, the tagged and normalized information is written into a standardized format\u00a0 typically JSON or XML\u00a0 and pushed into the <\/span>candidate database<\/b><\/a>. At this point a document that no two recruiters would have read the same way becomes a uniform record: every candidate has the same fields, populated the same way, ready to query.<\/span><\/p>\n

That structure is the whole point. It is what powers <\/span>semantic search<\/b> (“find me candidates with payments experience” returns fintech engineers, not just literal keyword matches), instant filtering by years of experience, and automated ranking against a role.<\/span><\/p>\n

The full pipeline, in order:<\/span><\/p>\n

    \n
  1. Ingest<\/b> the file and detect its format (PDF, DOCX, image, etc.).<\/span><\/li>\n
  2. Extract<\/b> raw text, using OCR for scanned or image-based documents.<\/span><\/li>\n
  3. Normalize<\/b> layout so multi-column and boxed content reads in the correct order.<\/span><\/li>\n
  4. Tag<\/b> entities\u00a0 name, contact, employers, titles, dates, education, skills.<\/span><\/li>\n
  5. Map<\/b> skills and titles to a standard taxonomy to remove variant spellings.<\/span><\/li>\n
  6. Structure<\/b> the result into JSON\/XML fields.<\/span><\/li>\n
  7. Load<\/b> the record into the candidate database for search, filtering, and scoring.<\/span><\/li>\n<\/ol>\n

    \"AI<\/p>\n

    Architecture and Model Choices Behind the Parse<\/b><\/h3>\n

    Not all parsing engines are built the same, and the architecture choice shows up directly in accuracy. Rule-based parsers\u00a0 the first generation\u00a0 rely on fixed patterns and regular expressions, which work on tidy resumes and collapse on anything unusual. A modern AI Resume Parser instead layers a machine learning model on top, so the system generalizes to formats it has never seen rather than matching rigid rules.<\/span><\/p>\n

    The current state of the art uses deep learning and, increasingly, large language models that interpret a resume the way an experienced recruiter does: by reading context, not just keywords. The practical trade-off is precision versus coverage. Many production systems run a hybrid design, a confident ML extraction with a rule-based fallback for high-stakes fields like certifications or compliance data, so a low-confidence guess never silently corrupts a record. When a vendor describes its AI Resume Parser, the architecture question to ask is simple: what happens when the model is unsure?<\/span><\/p>\n

    Integration, Cost, and Bulk Processing<\/b><\/h3>\n

    Extraction accuracy means little if the structured output cannot reach your hiring stack cleanly. The strongest setups expose an API and native connectors so parsed records flow straight into the applicant tracking system without a manual export-import step\u00a0 because a parse that still needs re-keying has saved nobody any time. Format support should span PDF, DOCX, RTF, TXT, and image files so the AI Resume Parser handles whatever candidates actually send.<\/span><\/p>\n

    Cost is the other axis startups underestimate. Some tools price per parse, some per recruiter seat, and the model you choose quietly shapes hiring behavior\u00a0 per-seat pricing, for instance, discourages adding reviewers exactly when a hiring sprint needs them. <\/span>Bulk <\/b>resume screening<\/b><\/a> is where the economics land: a capable AI Resume Parser handles hundreds or thousands of documents in a single batch, which is the difference between migrating years of archived resumes in an afternoon and never migrating them at all.<\/span><\/p>\n

    What “94% Accuracy” Actually Means<\/b><\/h3>\n

    Vendors love a single accuracy number, but AI resume parser accuracy rate is not one figure, it is a per-field measurement. Names, emails, and phone numbers parse at near-perfect rates because they follow predictable patterns. Free-form fields like skill context and nuanced job responsibilities sit lower. Benchmarks generally report 94\u201399% on clean, chronologically formatted resumes, with accuracy declining as layouts get more creative. The honest way to read a “94%” claim for an AI Resume Parser is to ask: 94% on which fields, across which document formats?<\/span><\/p>\n

    Where Parsers Still Fail<\/b><\/h3>\n

    Three document types remain genuinely hard, and pretending otherwise is how teams get burned. <\/span>Parsing scanned PDF resumes<\/b><\/a> depends entirely on OCR quality; a faxed or photographed CV introduces character errors that cascade into mis-tagged fields. Complex tables are the second weak spot\u00a0 when a candidate lays out skills or experience in a grid, the AI Resume Parser can read cells in the wrong order and stitch unrelated data together. Multi-column “designer” resumes are the third, for the same reading-order reason.<\/span><\/p>\n

    A few smaller failure modes are worth naming. Non-standard date formats and overlapping employment ranges confuse experience calculations. Heavy graphics, logos, and embedded charts can swallow nearby text. And resumes in mixed languages stress the model unless it was trained for multilingual input. None of these makes an AI Resume Parser unusable; they make the case for keeping a correction step in the workflow rather than trusting every field blindly.<\/span><\/p>\n

    The compliance dimension matters here too. Because parsed data flows automatically into hiring decisions, mature systems keep audit trails, support data-privacy requirements, and allow recruiters to correct extractions that feed back in to retrain the model over time.<\/span><\/p>\n

    AI Resume Screening: What Happens After the Parse<\/b><\/h2>\n

    Parsing is extraction; <\/span>AI Resume Screening<\/b> is judgment. Once a resume is structured, the screening layer scores it against the role\u00a0 weighing skills, experience depth, and qualifications\u00a0 and surfaces the strongest matches first. The cleaner the parse, the more reliable the score, which is why an AI Resume Parser and the screening layer are so tightly coupled.<\/span><\/p>\n

    This is also where structured data starts compounding in value. A well-parsed record makes <\/span>candidate shortlisting<\/b> close to instant: instead of reading 250 resumes, a recruiter reviews a ranked list and spends their attention on the top tier. Reported gains are substantial; an AI Resume Parser feeding a matching layer can cut time-to-hire by up to 75% and improve match accuracy by around 40% over plain keyword search.<\/span><\/p>\n

    Demo suggestion for publishing:<\/b> Add a short screen recording or GIF here showing a resume dropped into the AI Resume Parser and the structured fields\u00a0 name, skills, experience, education\u00a0 populating in real time, followed by the candidate appearing in a ranked shortlist. A side-by-side of raw resume and parsed output makes the value obvious at a glance.<\/span><\/p>\n

    Candidate Profile Management at Scale<\/b><\/h3>\n

    Strong <\/span>Candidate Profile Management<\/b><\/a> is the quiet payoff of good parsing. Every applicant becomes a complete, consistent profile in one place, so a candidate who was not right for a March role can be resurfaced in seconds for a June opening\u00a0 turning a one-time application pool into a reusable talent pipeline. For SMBs that hire in bursts, this rediscovery effect often delivers more value than the initial screen.<\/span><\/p>\n

    Structured profiles also feed the rest of the hiring stack. They populate automated <\/span>Recruitment Email Templates<\/b><\/a> with the correct candidate details for status updates, interview invitations, and rejections, removing the copy-paste errors that creep in under volume. And they close the loop with the <\/span>Job Posting Software<\/b><\/a> that generated the application in the first place, so a role advertised across multiple channels lands every applicant into one normalized database rather than a scatter of inboxes and spreadsheets.<\/span><\/p>\n

    One platform built around this flow, Hirium, treats parsing as the entry point to that wider system rather than a standalone trick\u00a0 the parse feeds screening, shortlisting, tracking, and outreach without manual re-keying.<\/span><\/p>\n

    \"Resume<\/p>\n

    Case Study: Two Real-World Hiring Scenarios<\/b><\/h2>\n

    A 30-person SaaS startup running an engineering hiring sprint received over 600 applications across four roles in three weeks. Manual screening would have consumed an estimated 15\u201320 recruiter hours per week; routing every resume through an <\/span>AI Resume Parser<\/b> and screening layer compressed the first-pass review to under two hours total, and the team filled all four roles roughly a third faster than its previous sprint. Just as important, no qualified applicant was lost to fatigue, because every resume was read with the same rigor as the first.<\/span><\/p>\n

    In a second scenario, a fast-growing services SMB migrated several years of archived resumes, many of them older scanned PDFs\u00a0 into a centralized candidate database. Re-parsing that backlog with an AI Resume Parser surfaced dozens of previously buried qualified candidates, two of whom were hired for new roles without spending a rupee on fresh sourcing. The outcome that mattered was not speed but recovery: value the company already owned but could not previously search. For an SMB watching its cost-per-hire, rediscovering a candidate is close to free compared with running a new sourcing campaign.<\/span><\/p>\n

    Choosing an AI Resume Parser: A Decision Framework<\/b><\/h2>\n

    Not every parser fits every team, and the right choice depends less on headline accuracy than on how an AI Resume Parser behaves on your actual document mix and how cleanly it connects to the rest of your hiring workflow. The table below frames the trade-offs that matter when evaluating the <\/span>best resume parsing software for startups<\/b><\/a> and SMBs.<\/span><\/p>\n\n\n\n\n\n\n\n\n
    Evaluation criterion<\/b><\/td>\nWhat to look for<\/b><\/td>\nWhy it matters<\/b><\/td>\n<\/tr>\n
    Format coverage<\/span><\/td>\nPDF, DOCX, RTF, and reliable OCR for scans<\/span><\/td>\nYour inbound mix is messier than vendor demos<\/span><\/td>\n<\/tr>\n
    Accuracy transparency<\/span><\/td>\nPer-field rates, not one blended number<\/span><\/td>\n“94%” hides where the misses actually happen<\/span><\/td>\n<\/tr>\n
    ATS integration<\/span><\/td>\nNative fit with your candidate database<\/span><\/td>\nA parse that needs re-keying saves no time<\/span><\/td>\n<\/tr>\n
    Correction loop<\/span><\/td>\nEasy edits that retrain the model<\/span><\/td>\nReal-world layouts drift; the tool should adapt<\/span><\/td>\n<\/tr>\n
    Pricing model<\/span><\/td>\nFlat, predictable, no per-recruiter fees<\/span><\/td>\nVolume hiring shouldn’t penalize you per seat<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    A short rule of thumb: if a vendor will not show you parsing results on a batch of <\/span>your<\/span><\/i> resumes\u00a0 including the ugly scanned ones\u00a0 treat the published accuracy figure as marketing, not evidence.<\/span><\/p>\n

    Weighting these criteria depends on your situation. A high-volume consumer brand drowning in scanned applications should weigh OCR and format coverage heavily. A technical team hiring engineers should prioritize skill-mapping depth and taxonomy quality, since that determines whether a search for niche frameworks actually returns the right people. And any team that hires in unpredictable bursts should care most about pricing structure and integration, because an AI Resume Parser that punishes you for adding reviewers or forces manual data transfer will erode its own time savings the moment volume climbs.<\/span><\/p>\n

    What Most Teams Get Wrong About Resume Parsing<\/b><\/h2>\n

    The most common mistake is treating the parser as a magic filter and walking away. <\/span>AI resume parser vs <\/b>ATS solutions<\/b><\/a> is a real distinction, but neither one should be making final cuts unsupervised. The system’s job is to triage and rank so humans spend their judgment where it counts, not to auto-reject candidates no one ever sees.<\/span><\/p>\n

    The second mistake is ignoring the input. Teams obsess over the model and never audit their own document pipeline, then blame the AI Resume Parser when accuracy dips\u00a0 when the real cause is a flood of scanned PDFs or table-heavy templates the system was never tuned for. Parsing quality is an input problem as much as a model problem.<\/span><\/p>\n

    The third, and most costly, is underusing the structured data once it exists. Most teams use parsing only for the live role and let every other profile go cold. The genuinely high-leverage move is treating the parsed candidate database as a permanent, searchable asset, the difference between paying to source the same talent twice and rediscovering candidates you already have. The parse is cheap; the database it builds is the durable advantage.<\/span><\/p>\n

    A fourth, quieter error is skipping the human correction loop. Teams deploy an AI Resume Parser, see strong accuracy in the demo, and never wire in a way for recruiters to fix the occasional mis-tag. Those corrections are not busywork\u00a0 in a well-built system; they retrain the model, so the parser that handles your particular resume mix gets measurably better over the first few months. Treating extraction as set-and-forget leaves that compounding improvement on the table.<\/span><\/p>\n

    \"Manual<\/p>\n

    Frequently Asked Questions<\/b><\/h2>\n

    How accurate is an AI resume parser?\u00a0<\/b><\/h3>\n

    On clean, well-structured resumes, modern parsers report 94\u201399% accuracy, but the number varies by field. Names, emails, and phone numbers extract at near-perfect rates, while free-form skill context and nuanced responsibilities are lower. Accuracy also drops on creative layouts and scanned documents, so always ask for per-field results on your own resume mix rather than a single blended figure.<\/span><\/p>\n

    Can an AI resume parser read scanned PDFs?\u00a0<\/b><\/h3>\n

    Yes, but with caveats. A scanned resume is an image, so the AI Resume Parser relies on optical character recognition to reconstruct the text first. Clear, high-resolution scans parse well; faxed, photographed, or low-quality scans introduce character errors that can cascade into mis-tagged fields. If your inbound includes many scans, OCR quality should be a primary evaluation criterion.<\/span><\/p>\n

    How does a parser handle tables and multi-column resumes?\u00a0<\/b><\/h3>\n

    This is one of the harder cases. Tables and multi-column “designer” layouts disrupt the natural reading order, so a weaker engine may read cells in the wrong sequence and merge unrelated information. Stronger systems rebuild the document’s logical structure before tagging fields, but no parser is flawless here; these formats are worth spot-checking manually during evaluation.<\/span><\/p>\n

    Is AI resume parsing the same as AI Resume Screening?\u00a0<\/b><\/h3>\n

    No. Parsing is extraction\u00a0 turning an unstructured resume into structured fields. Screening is the judgment layer that scores and ranks those structured records against a role. They work in sequence: screening quality depends directly on parsing quality, since a model can only rank candidates accurately if the underlying data was extracted cleanly in the first place.<\/span><\/p>\n

    How long does it take to parse one resume?\u00a0<\/b><\/h3>\n

    Effectively seconds are often a fraction of a second per document\u00a0 and a modern AI Resume Parser processes hundreds or thousands in bulk. The practical time saving is enormous: screening 500 resumes manually can take 8\u201325 hours, while bulk parsing structures the same volume almost instantly, leaving recruiters to spend their hours on the shortlist rather than the slush pile.<\/span><\/p>\n

    Does AI resume parsing introduce bias?\u00a0<\/b><\/h3>\n

    It can reduce or amplify bias depending on implementation. Because parsing evaluates structured data points rather than gut impressions, it removes some of the subjective signals that creep into tired human screening. But models trained on biased historical data can inherit those patterns, which is why audit trails, anonymization options, and human oversight on final decisions are non-negotiable. If you are weighing a tool against your fairness goals, that is a good moment to talk to a specialist.<\/span><\/p>\n

    What is the best resume parsing software for startups?<\/b><\/h3>\n

    There is no single answer, but the right fit for a startup usually prioritizes three things over raw accuracy claims: predictable flat pricing that does not penalize you per recruiter, native integration so parsed records land directly in your candidate database, and reliable handling of messy real-world formats. The best test is practical: run your own resume backlog through an AI Resume Parser on a free or trial plan and judge the structured output before you commit a budget.<\/span><\/p>\n

    \"Resume<\/p>\n

    Where to Go From Here<\/b><\/h2>\n

    If you are evaluating an AI Resume Parser and want to pressure-test it before committing, do one thing first: run a real batch of your own resumes\u00a0 including the scanned and table-heavy ones\u00a0 through any tool you are considering, and check the structured output field by field. That single test tells you more than any published accuracy number.<\/span><\/p>\n

    When you are ready to see an AI Resume Parser inside a full hiring workflow\u00a0 screening, shortlisting, tracking, and candidate rediscovery in one place\u00a0 <\/span>Hirium<\/b><\/a> offers a forever-free plan with no credit card required, so you can test the parse on your own pipeline before scaling up. Start with your messiest stack of resumes and watch what comes out the other side.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

    A single corporate opening pulls in roughly 250 applications, yet a recruiter gives each resume about 7.4 seconds before deciding to keep reading or move on. Run that math across a 20-role pipeline and one recruiter is staring down 5,000 documents\u00a0 most of which will never get a fair second look by a human being. […]<\/p>\n","protected":false},"author":3,"featured_media":1388,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8],"tags":[],"class_list":["post-1387","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-ai-in-recruitment"],"_links":{"self":[{"href":"https:\/\/hirium.com\/blog\/wp-json\/wp\/v2\/posts\/1387","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/hirium.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/hirium.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/hirium.com\/blog\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/hirium.com\/blog\/wp-json\/wp\/v2\/comments?post=1387"}],"version-history":[{"count":1,"href":"https:\/\/hirium.com\/blog\/wp-json\/wp\/v2\/posts\/1387\/revisions"}],"predecessor-version":[{"id":1394,"href":"https:\/\/hirium.com\/blog\/wp-json\/wp\/v2\/posts\/1387\/revisions\/1394"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/hirium.com\/blog\/wp-json\/wp\/v2\/media\/1388"}],"wp:attachment":[{"href":"https:\/\/hirium.com\/blog\/wp-json\/wp\/v2\/media?parent=1387"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/hirium.com\/blog\/wp-json\/wp\/v2\/categories?post=1387"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/hirium.com\/blog\/wp-json\/wp\/v2\/tags?post=1387"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}