docs APIdocs.gl ↗
Access OpenGL and GLES function documentation, signatures, parameters, version support, and categories via 5 structured endpoints backed by docs.gl.
What is the docs API?
The docs.gl API exposes OpenGL and GLES reference documentation across 5 endpoints, returning function signatures, parameter descriptions, error conditions, version availability, and sidebar category groupings. The get_function_detail endpoint delivers the full documentation record for any named function — including its title, signature, parameters, notes, and see-also links — under a specific version context such as gl4, es3, or gl2.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/ac3fb051-6c34-4db6-8696-b3b4482a392d/get_function_list' \ -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 docs-gl-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.
"""docs.gl SDK — OpenGL/GLES function documentation lookup workflow."""
from parse_apis.docs_gl_api import DocsGL, VersionPrefix, FunctionNotFound
client = DocsGL()
# Browse function categories to understand the API surface
for cat in client.categories.list(limit=3):
print(cat.category, f"({len(cat.functions)} functions)")
for fn in cat.functions[:2]:
print(f" {fn.name} versions={fn.versions}")
# Search for texture-binding functions by substring match
result = client.searchresults.search(query="BindTexture", limit=1).first()
if result:
print(result.name, result.version, result.path)
# Get full documentation for a specific function using the enum
func = client.functions.get(function_name="glDrawArrays", version=VersionPrefix.GL4)
print(func.name, func.signature)
for param in func.parameters:
print(f" {param.name}: {param.description[:60]}")
# Navigate from summary to detail via resource method
summary = client.functionsummaries.list(limit=1).first()
if summary:
detail = summary.details()
print(detail.name, detail.url)
for related in detail.see_also[:3]:
print(f" see also: {related.name}")
# List function names available in OpenGL ES 3.x
for name in client.functionsummaries.list_by_version(version=VersionPrefix.ES3, limit=5):
print(name)
# Handle a missing function gracefully
try:
client.functions.get(function_name="glNonExistent", version=VersionPrefix.GL4)
except FunctionNotFound as exc:
print(f"not found: {exc.function_name}")
print("exercised: categories.list / searchresults.search / functions.get / functionsummaries.list / details / list_by_version")
Retrieves the complete catalog of OpenGL/GLES functions with the version strings each appears in. Returns every function known to docs.gl. The result set is large (4000+ entries) and not paginated server-side; a single request fetches everything.
No input parameters required.
{
"type": "object",
"fields": {
"items": "array of objects each with 'name' (string) and 'versions' (array of version strings like 'gl2.1', 'gl4.5', 'es3.0')",
"total": "integer, count of items returned"
},
"sample": {
"data": {
"items": [
{
"name": "glAccum",
"versions": [
"gl2.1",
"gl3.0",
"gl3.1"
]
},
{
"name": "glActiveTexture",
"versions": [
"gl2.1",
"gl3.0",
"gl3.1"
]
}
],
"total": 4154
},
"status": "success"
}
}About the docs API
Function Coverage and Version Filtering
The get_function_list endpoint returns every function known to docs.gl as an array of objects, each carrying a name and a versions array containing strings like gl2.1, gl4.5, or es3.0. If you need only the functions available in a particular generation of the API, get_function_list_by_version accepts a version prefix (gl2, gl3, gl4, es2, es3) and returns a sorted array of matching function names. The prefix match covers all sub-versions beneath it — supplying gl4 returns functions from gl4.0 through gl4.5.
Detailed Function Documentation
get_function_detail is the core lookup endpoint. Supply a function_name (e.g. glDrawArrays, glBindTexture) and an optional version context, and the response object includes name, version, url, title, signature, a parameters array (each entry has name and description), description, notes, errors, examples, version support details, and see_also links. Not every function exists under every version prefix — legacy GL2-only functions like glLightfv are absent from gl4 pages — so the version parameter should match where the function actually lives.
Search and Category Navigation
search_functions performs a case-insensitive substring match against function names across all versions and returns objects containing name, a specific version string (e.g. gl4.5), and a path URL segment. This is useful for partial-name lookups when the exact function name is uncertain. get_functions_by_category returns the full sidebar taxonomy as an array of objects, each with a category string (e.g. Textures, Rendering, Frame Buffers) and a functions array whose entries carry name, href, and versions. This mirrors the organizational structure used in the docs.gl navigation.
The docs API is a managed, monitored endpoint for docs.gl — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when docs.gl 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 docs.gl 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?+
- Build an IDE extension that surfaces OpenGL function signatures and parameter docs inline as developers type.
- Generate version-specific cheat sheets by querying get_function_list_by_version for gl4 or es3 and formatting the sorted output.
- Populate autocomplete in a graphics shader editor using search_functions substring matches against partial function names.
- Create a diff view of which functions were added between OpenGL versions by comparing get_function_list_by_version results for gl3 and gl4.
- Organize a learning resource by iterating get_functions_by_category to group functions under Textures, Rendering, and Frame Buffers headings.
- Validate that a function exists in a target OpenGL ES version before shipping mobile graphics code, using the versions array from get_function_detail.
- Build a static documentation mirror or offline reference tool by bulk-fetching get_function_detail for every function in get_function_list.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.