I built a GitHub repository intelligence API — here's what I learned

Every open source maintainer I've talked to has the same problem.

Their GitHub issues are a mess. Missing descriptions. No labels. Tickets open for 8 months with zero activity. New contributors picking up issues that turn out to be 3-week architectural rewrites with no warning.

The manual triage never ends.

So I built RepoAudit — a REST API that audits any public GitHub repository and returns two things: a data quality report and AI-powered complexity scores per issue. One API call. Structured JSON back.

Here's what I learned building it.

What it actually does

Send a POST request with a repo name:

{
  "repo": "facebook/react",
  "issue_numbers": "36807,36810"
}

Get back a full audit:

{
  "data_quality": {
    "total_open_issues": 247,
    "missing_descriptions": 38,
    "missing_labels": 54,
    "stale_issues_90d": 91,
    "label_consistency_score": 0.61,
    "flagged_issues": [...]
  },
  "issue_complexity": [
    {
      "issue_number": 36807,
      "complexity": "medium",
      "effort_estimate": "4-8 hours",
      "skill_tags": ["React", "CI/CD", "GitHub Actions"],
      "risk_flags": ["Missing configuration files"],
      "suggested_approach": "Investigate the CI config and update the codesandbox job."
    }
  ],
  "summary": "Repo has 247 open issues. 38 lack descriptions, 91 are stale."
}

The architecture

The API is built in TypeScript with Express. Six files, each with a single responsibility:

github.ts

— fetches issues from the GitHub REST API, paginated, with PRs filtered outauditor.ts

— deterministic data quality analysis (no AI, runs fast and free)scorer.ts

— sends issues to Groq's Llama 3.3 70B in batches of 10 for complexity scoringrouter.ts

— Express routes with API key auth and per-tier rate limitingtypes.ts

— shared TypeScript interfacesindex.ts

— entry pointThe key design decision was separating the data quality analysis from the AI scoring. The quality checks, missing descriptions, stale issues, label consistency, are deterministic. They run in milliseconds and cost nothing. The AI scoring is where the real latency and cost lives.

This means if the AI call fails or rate limits, the quality report still delivers. Partial output is better than no output.

What I got wrong first

My first version had the AI scoring all open issues in one batch. On a repo like facebook/react

with 500+ open issues, that meant 50+ API calls to Groq in sequence. Total latency: several minutes.

The fix was obvious in hindsight, cap the AI scoring at 20 issues per call for full repo audits. When callers pass specific issue numbers, score all of them. When auditing an entire repo, score the first 20 and flag the rest with quality data only.

The rate limiting problem on Render

When I deployed to Render, the express-rate-limit package threw this error:

ValidationError: The 'X-Forwarded-For' header is set but

the Express 'trust proxy' setting is false.

Render sits behind a Cloudflare proxy. Without app.set('trust proxy', 1)

, the rate limiter can't identify users by IP — it sees every request as coming from the same proxy IP and either over-limits or under-limits everyone.

One line fix. But it took an hour to debug.

Three tier pricing

The API has three tiers:

Plan	Price	Limit
Free	$0	10 audits/day
Starter	$9/month	200 audits/day
Pro	$29/month	500 audits/day

Keys are stored in environment variables on Render. API_KEYS

for free tier, STARTER_KEYS

and PRO_KEYS

for paid. The router checks which list a key belongs to and applies the correct rate limiter dynamically.

Not elegant — but it works at zero customers and I can migrate to a database when I actually have customers to migrate.

What's next

The obvious next step is a GitHub App — install it on your repo and every new issue gets automatically scored as it's filed. No API call required from the maintainer. That's the stickiest version of this product.

But I'm not building it yet. First I want to see if anyone pays for the REST API. If they do, I'll know the core value is real and the GitHub App is worth the extra engineering.

Try it

Free tier is 10 audits/day, no credit card required.

Landing page: repoaudit-api.vercel.app

GitHub: github.com/KingDavid9999/repoaudit-api

RapidAPI: rapidapi.com/KingDavid9999/api/repoaudit

If you're building something that needs repo intelligence, that is, bounty platforms, contributor matching, project management tools — I'd love to hear what you're working on.

source & further reading

dev.to — original article Swap Your LLM Without a Deploy: Dynamic Model Routing on Bedrock with AWS AppConfig MCP's Tasks Extension Lets a Tool Call Run in the Background — If You Get the Object Shape Right AI Model Routing: The Missing Infrastructure Layer for Multi-Model AI Applications