What is GraphQL?

GraphQL is a query language for APIs. Instead of hitting different URL endpoints for different data, you send a single request to one endpoint describing exactly what you want back.

LeetCode’s API lives at one URL: https://leetcode.com/graphql

Everything — stats, recent submissions, problem lists — comes from that single endpoint.

HTTP vs GraphQL

With a standard HTTP REST API (like what you might have used with Axios), the server decides what data comes back:

GET /users/AdumbRock          → returns the whole user object
GET /users/AdumbRock/solved   → returns solved problems
GET /users/AdumbRock/recent   → returns recent submissions

You have no control over the shape of the response. If the server sends 30 fields, you get 30 fields whether you need them or not.

With GraphQL, you write the query and the server returns only what you asked for:

query {
	matchedUser(username: "AdumbRock") {
		username
		submitStats {
			acSubmissionNum {
				difficulty
				count
			}
		}
	}
}

The response will only contain username, difficulty, and count. Nothing more.

How It’s Sent

Under the hood, a GraphQL request is still just an HTTP POST request. The difference is what’s in the body:

# Standard REST with requests
response = requests.get("https://api.example.com/users/AdumbRock")

# GraphQL with requests — still HTTP POST, query goes in the body
response = requests.post(
    "https://leetcode.com/graphql",
    json={"query": "...", "variables": {"username": "AdumbRock"}},
    headers={"Content-Type": "application/json"},
)

The json= body has two keys:

• query — the GraphQL query string
• variables — values to inject into the query (like username)

The response is always JSON with a data key at the top level:

{
  "data": {
    "matchedUser": {
      "username": "AdumbRock",
      "submitStats": { ... }
    }
  }
}

Advantages of GraphQL over REST

1. You get exactly what you ask for REST returns whatever the server decided to include. GraphQL returns only the fields you listed in your query. Less data transferred, no wasted parsing.

2. One endpoint instead of many A REST API might have /users, /users/:id/submissions, /users/:id/stats, etc. GraphQL has one URL. You change what you fetch by changing the query, not the URL.

3. Strongly typed schema The API publishes a schema that describes every available field and its type. You know upfront what you can query — no guessing or reading docs to find out if a field exists.

4. Fetch related data in one request With REST you often need multiple requests to build a full picture (fetch user, then fetch their submissions, then fetch each problem’s details). With GraphQL you can nest all of that into a single query.

Tradeoff worth knowing: GraphQL adds complexity on the server side to build and maintain the schema. For simple or public APIs, REST is often still the right choice. LeetCode happens to expose GraphQL publicly, which is why we use it here.

Why __init__.py in the leetcode/ folder?

This is a common Python pattern. When you create a folder with an __init__.py inside it, Python treats that folder as a package. The __init__.py file is what runs when you import the package.

services/
└── leetcode/
    └── __init__.py   ← this IS the leetcode module

So when main.py does:

from services.leetcode import get_stats, get_recent_solved

Python runs services/leetcode/__init__.py and pulls those functions from it.

It’s a clean way to keep a service’s logic self-contained. If the LeetCode service grows, you can split it into multiple files inside the leetcode/ folder and re-export them from __init__.py. The import in main.py never has to change.

How to Check your Browser for the right graphql query

1. Open your leetcode profile
2. Open the network tab in your dev tools and type graphql in the filter URL input field
3. Refresh the page
4. Look at the Request to get the query and variables

From DevTools to Code: get_recent_solved

Here’s exactly how the query found in DevTools became working Python code.

What DevTools showed:

query recentAcSubmissions($username: String!, $limit: Int!) {
	recentAcSubmissionList(username: $username, limit: $limit) {
		id
		title
		titleSlug
		timestamp
	}
}

Step 1 — Store the query as a string constant

The query is just text. In Python we store it in a variable so it can be reused:

RECENT_QUERY = """
query recentAcSubmissions($username: String!, $limit: Int!) {
  recentAcSubmissionList(username: $username, limit: $limit) {
    id
    title
    titleSlug
    timestamp
  }
}
"""

Step 2 — Supply the variables

The query declared two placeholders: $username and $limit. These get passed separately in the request body under a variables key:

json={
    "query": RECENT_QUERY,
    "variables": {"username": username, "limit": limit}
}

LeetCode’s server swaps $username and $limit for those values before running the query.

Step 3 — Unwrap the response

The response always comes back wrapped in { "data": { ... } }. We drill into it to get the actual list:

response.json().get("data", {}).get("recentAcSubmissionList", [])

recentAcSubmissionList matches the field name in the query exactly — that’s how GraphQL maps the response back to what you asked for.

Knowledge Check

query getUserStats($username: String!) {
	matchedUser(username: $username) {
		username
		submitStats {
			acSubmissionNum {
				difficulty
				count
			}
		}
	}
}