Structure · Profile Parsing API
Turn resume documents into structured profile data.
Upload one resume document or image. ProfileOut extracts and labels the available information asynchronously, then returns a JSON result for your application.
Alex Kim
Backend Engineer
Example Labs
Toronto, Canada
Designed APIs and data services.
Java · Python{
"info": {
"name": "Alex Kim"
},
"experiences": [
{
"company_name": "Example Labs",
"job_title": "Backend Engineer"
}
]
}Quick Facts
The file-parsing workflow at a glance.
How It Works
From a resume file to a labeled JSON result.
Upload a supported file, save request_id, and poll for the completed result. Available fields depend on the document and parsing schema.
Resume parsing workflow
One supported file per multipart request; no additional form fields.
- 01 Upload One supported file
- 02 Save ID Accepted request
- 03 Poll status Wait at least 5 seconds
- 04 Read result Check terminal state
- 05 Use JSON Validate nested fields
Document to JSON
Give document content a structured form.
Read the available identity and career information as JSON. The preview illustrates a possible output, not a guarantee that every field will be present.
Resume file content
Alex Kim
Backend Engineer
Example Labs
Toronto, Canada
Designed APIs and data services.
Java · Python{
"info": {
"name": "Alex Kim"
},
"experiences": [
{
"company_name": "Example Labs",
"job_title": "Backend Engineer"
}
]
}Illustrative file content and result excerpt. Nested parsing fields can be absent or have varying types; they do not automatically share the People Data schema.
Capabilities
Structure the professional data your systems already receive.
Extract and label information from customer-submitted resumes for your own application workflows.
Document ingestion
Upload one PDF resume using the multipart file field.
Image file input
Supported image formats are PNG, JPEG, and TIFF. The file extension must match its contents.
Structure understanding
Identify professional sections and entities before mapping them into structured fields.
Labeled profile information
Read extracted details and inferred classifications where present. Inferred labels are not independently verified facts.
Asynchronous processing
Use the saved request ID to follow queued, processing, completed, or failed states.
JSON result access
Read the parsed JSON object directly from result. Original file contents and storage paths are not returned.
Integration
Upload one file. Read the result by request ID.
These server-side examples upload one PDF. Let the client set the multipart boundary. Save request_id, then poll GET /v1/profile-parsings/{request_id} at the returned interval until completed or failed.
curl --request POST 'https://api.profileout.com/v1/profile-parsings' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--form 'file=@resume.pdf'import requests
with open("resume.pdf", "rb") as file:
response = requests.post(
"https://api.profileout.com/v1/profile-parsings",
headers={"Authorization": "Bearer YOUR_API_KEY"},
files={"file": ("resume.pdf", file, "application/pdf")},
timeout=30,
)
response.raise_for_status()
print(response.json()) # Save request_id and poll its GET route.import { readFile } from "node:fs/promises";
const form = new FormData();
form.append("file", new Blob([await readFile("resume.pdf")], {
type: "application/pdf",
}), "resume.pdf");
const response = await fetch("https://api.profileout.com/v1/profile-parsings", {
method: "POST",
headers: { Authorization: "Bearer YOUR_API_KEY" },
body: form, // Let fetch set the multipart boundary.
signal: AbortSignal.timeout(30000),
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json()); // Save request_id and poll.Parsing Output
A stable request envelope, document-dependent fields.
The completed response excerpt below is illustrative. Validate nested field presence and types rather than assuming every example field exists.
{
"request_id": "22222222-2222-4222-8222-222222222222",
"status": "completed",
"result": {
"info": {
"name": "Alex Kim"
},
"experiences": [
{
"company_name": "Example Labs",
"job_title": "Backend Engineer"
}
]
}
}Use Cases
Structure resume data before the next system uses it.
Profile Parsing fits resume ingestion workflows across products, data platforms, and recruiting technology.
People-data Products & Marketplaces
Convert uploaded resume documents or images into structured application records.
Data Enrichment
Extract available profile information from resumes before mapping it into your own record model.
AI Agents & Data Products
Prepare cleaner structured people data for downstream models, agents, analytics, and internal data workflows.
Recruiting & HR Tech
Normalize resumes and candidate documents before storing, enriching, matching, or searching professional records.
Pricing Rule
2 credits per file upload.
Each accepted file upload reserves 2 credits. Successful completion charges the credits; failed work releases them.
See Pricingper accepted file upload
- Accepted file upload
- 2 credits reserved
- Completed request
- 2 credits charged
- Failed work
- Reserved credits released
- Credit balance
- Shared across ProfileOut APIs
Trust & Limits
Make parsing behavior explicit before production.
File coverage, language support, missing fields, and processing behavior matter as much as a clean example response.
Supported source types
Accepts one non-empty PDF, PNG, JPEG, or TIFF file. DOCX, raw-text JSON bodies, and batch uploads are not supported.
File & request limits
Each file must be at most 10 MiB (10,485,760 bytes). The documented allowance is 100 new parsing requests per hour per account.
Missing or ambiguous fields
Nested fields may be omitted or vary in type. A completed result does not establish that every field was extracted or verified.
Execution & retention
Processing is asynchronous. Save results you need to retain; access to completed results can expire according to administrator settings.
FAQ
Profile Parsing API questions.
What does Profile Parsing accept?
The endpoint parses customer-submitted resume files in the documented formats. It does not accept arbitrary person JSON or raw text as alternative request bodies.
What inputs can I send?
Send exactly one file field in multipart/form-data. Supported formats are PDF, PNG, JPEG (.jpg or .jpeg), and TIFF (.tif or .tiff).
What does the API return?
The response includes request_id, status, and result. After completion, result is the parsed JSON object; while pending or failed it is null.
Are nested profile fields guaranteed?
No. Fields and types depend on the document and parsing schema. Example groups include info, experiences, and educations, but the API does not guarantee every nested field.
What size file can I upload?
The file must be non-empty and at most 10 MiB (10,485,760 bytes). Its extension must match its contents. Test representative files rather than assuming a language or extraction guarantee.
How should I handle missing fields?
Check whether each field exists and whether its type is usable for your application. Missing values do not automatically mean false, and successful processing does not guarantee completeness.
How is Profile Parsing different from People Data API?
Profile Parsing structures a resume file you upload. People Data retrieves a labeled profile from a supported social account identifier.
Turn resume files into usable structured data.
Test a supported resume file, inspect the result, and map the available fields into your application.