TL;DR
GitHunt now has a public REST API at api.githunt.ai and an MCP server (npx githunt-mcp) that puts developer search directly into the hands of recruiting platforms, sourcing teams, and AI agents. Three endpoints cover search, single-profile lookups, and deep profile analysis. Free plan includes 50 calls a month with no credit card, so you can try it before committing to anything.
Why we built this
Most of the people using GitHunt were not typing searches into a browser anymore. They were pasting our results into an ATS, forwarding them to a sourcing tool, or asking an AI agent to do the legwork for them. The inbound requests followed the same pattern: "can we call this from our platform," "can our sourcing bot query this directly," "do you have an API."
Agents are becoming the new recruiters. Not replacing recruiters, but doing the first pass, the repeat sourcing runs, the "find me ten more like this one" queries that used to eat an afternoon. That work needs a stable, documented interface, not a browser session someone has to babysit.
So we built one. A public REST API for anyone integrating developer search into their own stack, and an MCP server for anyone whose "stack" is an AI agent with a tool-calling loop.
What you can do with it
POST /v1/search is the core of the API. Send a location, role, skills, and languages, and it returns ranked candidates with scores and contact info - millisecond access to millions of developers available on GitHub, fast enough to embed in a live product flow instead of a background job.
GET /v1/users/{login} looks up a single developer by GitHub login and returns their ranked profile. Useful when you already have a candidate in mind, from a referral, a conference talk, an open-source PR, and want GitHunt's scoring and contact extraction on that one person without running a full search.
POST /v1/profile/analyze goes deeper: proficiency level, role fit, and extracted emails from a live analysis of the profile. This one talks to GitHub in real time rather than the cache, so it is slower than search, but it is the endpoint to reach for when you need a real assessment of one candidate rather than a ranked list of many.
Quickstart: REST
Get an API key from the Account page (githunt.ai/account, API tab). It is shown once at creation, so store it somewhere safe. Every request needs it as a Bearer token or an X-Api-Key header.
curl -X POST https://api.githunt.ai/v1/search \
-H "Authorization: Bearer ghk_live_xxxxxxxxxxxx" \
-H "Content-Type: application/json" \
-d '{
"location": "Warsaw, Poland",
"role": "backend",
"skills": ["go", "kubernetes"]
}'
A trimmed response:
{
"success": true,
"data": {
"matchedCount": 25,
"results": [
{
"login": "example-dev",
"score": 91,
"profile_score": 26,
"tech_stack_score": 38,
"activity_score": 22,
"matching_keywords": "go, kubernetes",
"location": "Warsaw, Poland"
}
]
},
"meta": {
"quota": { "used": 1, "limit": 50, "month": "2026-07" }
}
}
Every response includes the quota block, so your integration can self-throttle instead of guessing when it is about to hit a limit.
Quickstart: MCP
If your "integration" is an AI agent rather than application code, skip the HTTP client and run the MCP server instead:
{
"mcpServers": {
"githunt": {
"command": "npx",
"args": ["githunt-mcp"],
"env": {
"GITHUNT_API_KEY": "ghk_live_..."
}
}
}
}
Drop that into Claude Code, Claude Desktop, Cursor, or any other MCP-capable agent, and GitHunt shows up as three native tools: search_developers, get_developer, and analyze_profile. From there you can just ask, in plain language:
"Find me senior Go engineers in Poland and analyze the top 3."
The agent calls search_developers, ranks the results, then calls analyze_profile on the candidates it picks, no glue code required on your end.
Quotas and pricing
| Plan | API calls / month | Notes |
|---|---|---|
| Free | 50 | No credit card, works as a trial |
| Pro | 1,000 | Same tier as the existing Pro subscription |
| Enterprise | Unlimited | For high-volume pipelines |
Quota is shared across all three endpoints and resets monthly. If you are already on a paid GitHunt plan, your API quota is included, there is no separate charge to turn the API on.
Docs and what's next
Full reference lives at githunt.ai/api-docs, with an OpenAPI spec at githunt.ai/openapi.yaml you can import directly into Postman, Insomnia, or your own codegen pipeline. If you are wiring GitHunt into an agent framework rather than MCP, the agent-builder guide has ready-to-paste tool definitions for both Anthropic and OpenAI function-calling formats.
This is a v1. We built it for three groups: recruiting platforms embedding developer search into their existing product, sourcing teams automating candidate pipelines instead of running the same manual searches every week, and builders of AI sourcing agents who need a real data source instead of a scraper. If you are one of those and something is missing, tell us, through the contact page or directly, since this is the version we intend to keep shaping around real usage rather than guesses.