Vercel APIthe-talent-os.vercel.app ↗
Analyze GitHub profiles, parse LeetCode stats, extract job description fields, and generate AI career roadmaps with 4 endpoints from The Talent OS API.
What is the Vercel API?
The Talent OS API provides 4 endpoints that turn developer activity and job postings into structured career intelligence. The analyze_github endpoint scores a GitHub user across five skill categories — frontend, backend, AI, DevOps, and open-source — alongside a full language breakdown by repository count. Companion endpoints cover LeetCode problem-solving statistics, job description parsing, and AI-generated learning roadmaps.
curl -X GET 'https://api.parse.bot/scraper/9a7577d3-1ef4-4a3b-90d1-6fa6f7b6f51f/analyze_github?username=torvalds' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace the-talent-os-vercel-app-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: TalentOS Roadmap Finder SDK — bounded, re-runnable; every call capped."""
from parse_apis.the_talent_os_vercel_app_api import TalentOS, ParseError
client = TalentOS()
# Analyze a GitHub profile to understand skills and scores
github = client.github_profiles.get(username="torvalds")
print(github.username, github.overall_score, github.backend_score)
for lang in github.languages[:3]:
print(lang.language, lang.count, lang.percentage)
# Analyze a LeetCode profile for problem-solving stats
leetcode = client.leetcode_profiles.get(username="neal_wu")
print(leetcode.username, leetcode.total_solved, leetcode.acceptance_rate)
# Generate a personalized career roadmap
roadmap = client.roadmaps.generate(message="Create a 30-day roadmap for learning React.js")
print(roadmap.response[:200])
# Parse a job description to identify required skills
jd = client.job_descriptions.parse(text="Senior Backend Engineer - 5+ years Python, Django, AWS, PostgreSQL")
print(jd.title, jd.skills, jd.technologies)
# Typed error handling
try:
profile = client.github_profiles.get(username="nonexistent-user-xyz-12345")
print(profile.username)
except ParseError as e:
print(f"error: {e.code}")
print("exercised: github_profiles.get, leetcode_profiles.get, roadmaps.generate, job_descriptions.parse")
Analyze a GitHub user profile to produce skill category scores (frontend, backend, AI, DevOps, open-source) and a language breakdown by repository count. One round-trip per call; no pagination.
| Param | Type | Description |
|---|---|---|
| usernamerequired | string | GitHub username or organization name to analyze. |
{
"type": "object",
"fields": {
"ai_score": "number",
"username": "string",
"languages": "array of language objects with language, count, percentage",
"forks_count": "integer",
"devops_score": "number",
"backend_score": "number",
"overall_score": "number",
"frontend_score": "number",
"stargazers_count": "integer",
"open_source_score": "number",
"total_repositories": "integer"
},
"sample": {
"ai_score": 76,
"username": "torvalds",
"languages": [
{
"count": 10,
"language": "C",
"percentage": 83
}
],
"forks_count": 64532,
"devops_score": 79,
"backend_score": 83,
"overall_score": 83,
"frontend_score": 81,
"stargazers_count": 252315,
"open_source_score": 93.6,
"total_repositories": 12
}
}About the Vercel API
GitHub and LeetCode Profile Analysis
The analyze_github endpoint accepts a username and returns numeric scores for frontend_score, backend_score, ai_score, devops_score, and open_source_score, plus an overall_score. The languages array lists each programming language with its count and percentage share of repositories, while stargazers_count and forks_count give a sense of public impact. The analyze_leetcode endpoint takes a LeetCode username and returns solved counts broken down by easy_solved, medium_solved, and hard_solved, plus total_solved, contest_rating, acceptance_rate, and global ranking. Both endpoints complete in a single round-trip with no pagination.
Job Description Parsing
The parse_job_description endpoint accepts a raw job posting string in the text field and extracts: title, skills (required skill list), technologies, experience, education, location, salary, industry, employment_type, and nice_to_have. This makes it straightforward to compare a developer's GitHub skill scores against the skills and technologies a specific role demands.
AI Career Roadmap Generation
The generate_roadmap endpoint accepts a message describing a career goal or skill gap and returns a response string containing a structured roadmap with phases, daily plans, and recommendations. An optional history parameter accepts a JSON-encoded array of prior conversation turns, enabling multi-turn dialogue so follow-up questions refine or extend an earlier roadmap without losing context.
The Vercel API is a managed, monitored endpoint for the-talent-os.vercel.app — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when the-talent-os.vercel.app changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official the-talent-os.vercel.app API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Score candidates' GitHub profiles against job description
technologiesandskillsfields to filter applicants. - Display a developer's
frontend_scoreandbackend_scoreside-by-side with a target job's required skills. - Build a dashboard that tracks
contest_ratingandhard_solvedgrowth on LeetCode over time. - Automatically parse inbound job postings to extract
salary,location, andexperienceinto a structured database. - Generate a 30-day learning roadmap via
generate_roadmapbased on the gap between a user's GitHub scores and a parsed job's requiredtechnologies. - Identify the dominant
languagesin a GitHub profile to recommend relevant open-source projects to contribute to. - Use multi-turn
historycontext ingenerate_roadmapto iteratively refine a roadmap as a user asks follow-up questions.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does The Talent OS have an official developer API?+
What does `analyze_github` return beyond skill scores?+
overall_score, the response includes a languages array where each entry carries the language name, the number of repositories using it, and its percentage share. It also returns stargazers_count and forks_count as aggregate signals across the user's public repositories.Does `analyze_leetcode` return per-problem or contest history data?+
total_solved, easy_solved, medium_solved, hard_solved, contest_rating, acceptance_rate, and ranking. Per-problem submission history and individual contest result breakdowns are not currently exposed. You can fork this API on Parse and revise it to add endpoints covering that detail.Can `parse_job_description` handle multiple job postings in a single call?+
Does `generate_roadmap` support saving or retrieving past roadmaps?+
message and optional history parameter, but it does not persist or retrieve previously generated roadmaps by ID. Conversation continuity is managed by passing prior turns in the history field on each new request. Persistent roadmap storage is not currently part of the API. You can fork it on Parse and revise to add storage and retrieval endpoints.