Solidity Lang APIsoliditylang.org ↗
Access Solidity documentation pages, compiler versions, blog posts, and the known-bugs database via 8 structured endpoints from soliditylang.org.
What is the Solidity Lang API?
The Solidity Lang API exposes 8 endpoints covering the official Solidity language documentation, release blog posts, and the compiler bug database maintained at soliditylang.org. You can fetch full doc pages with get_doc_page — returning HTML content, raw RST source, and extracted headings — or query get_bugs_by_version to map every compiler release to its known security issues, each tagged with a severity level and the version that introduced and fixed the bug.
curl -X GET 'https://api.parse.bot/scraper/89f5632c-3505-4e24-b021-33e4a5ec8587/get_documentation_home?version=latest' \ -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 soliditylang-org-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: Solidity SDK — documentation, blog, and compiler bug queries."""
from parse_apis.solidity_documentation___blog_api import (
Solidity, BlogCategory, ResourceNotFound, DocHome, BugIndex
)
solidity = Solidity()
# Get the documentation home page with table of contents
home = solidity.dochomes.get(version="latest")
print(home.title, home.version)
for entry in home.toc[:3]:
print(entry.title, entry.slug)
# Construct a version and search its pages for a topic
latest = solidity.docversion(slug="latest")
for result in latest.pages.search(query="mapping", limit=3):
print(result.title, result.path)
# Get a specific documentation page from that version
page = latest.pages.get(slug="types")
print(page.title, page.version)
for heading in page.headings[:3]:
print(heading.level, heading.text)
# List blog posts filtered by category using the enum
for post in solidity.blogposts.list(category=BlogCategory.RELEASES, limit=3):
print(post.title, post.date, post.author)
# Get a specific blog post detail with typed error handling
try:
detail = solidity.blogpostdetails.get(year="2026", month="04", day="29", slug="solidity-0.8.35-release-announcement")
print(detail.title, detail.date, detail.category)
except ResourceNotFound as exc:
print(f"Blog post not found: {exc.slug}")
# List known compiler bugs
for bug in solidity.bugs.list(limit=3):
print(bug.uid, bug.name, bug.severity, bug.introduced, bug.fixed)
# Get the full bugs-by-version index
index = solidity.bugindexes.get()
print(type(index.versions))
print("exercised: dochomes.get / pages.search / pages.get / blogposts.list / blogpostdetails.get / bugs.list / bugindexes.get")
Fetches the main Solidity documentation landing page for a given version, returning the table of contents and main content HTML. The ToC lists all top-level documentation sections with their slug, suitable for feeding into get_doc_page. Content is cleaned HTML with navigation artifacts removed.
| Param | Type | Description |
|---|---|---|
| version | string | Documentation version slug (e.g. 'latest', 'stable', 'v0.8.35'). |
{
"type": "object",
"fields": {
"toc": "array of objects with title, href, and slug for each documentation section",
"title": "string, page title from the HTML document",
"version": "string, the version slug requested",
"content_html": "string, cleaned HTML content of the main documentation body"
},
"sample": {
"data": {
"toc": [
{
"href": "introduction-to-smart-contracts.html",
"slug": "introduction-to-smart-contracts",
"title": "Introduction to Smart Contracts"
}
],
"title": "Solidity — Solidity 0.8.36-develop documentation",
"version": "latest",
"content_html": "<div class=\"document\">...</div>"
},
"status": "success"
}
}About the Solidity Lang API
Documentation Access
get_documentation_home retrieves the table of contents and main content HTML for any Solidity version — pass a version slug like v0.8.35, stable, or latest. get_doc_page goes deeper: supply a slug such as types, abi-spec, or security-considerations and get back the full content_html, the source_rst raw reStructuredText, and a headings array that includes level, text, and id for each heading in the page. list_doc_versions returns every available version with metadata fields including slug, verbose_name, built, active, and associated urls.
Search and Blog
search_documentation accepts a query string and an optional version filter, returning paginated results with count, next/previous pagination cursors, and per-result highlights and blocks. get_blog_posts lists all posts from the Solidity blog and accepts a category filter — releases, security alerts, or announcements — returning each post's frontmatter (title, date, author, category) and content as a markdown string. get_blog_post fetches a single post by year, month, day, and slug, and also returns availableURLs for related resources.
Compiler Bug Database
get_known_bugs returns the full bug list from the Solidity GitHub repository. Each entry includes uid, name, summary, description, severity (e.g. high or low), introduced, and fixed version strings, plus a link to the corresponding blog post. get_bugs_by_version pivots that data: the response is a map keyed by version string, each containing a bugs array of bug name strings and a released date in YYYY-MM-DD format — useful for checking whether a specific compiler version carries any known issues.
The Solidity Lang API is a managed, monitored endpoint for soliditylang.org — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when soliditylang.org 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 soliditylang.org 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?+
- Audit a smart contract project by cross-referencing its compiler version against
get_bugs_by_versionto surface all known bugs affecting that release. - Build a documentation search tool for Solidity developers using
search_documentationwith version-scoped queries and highlighted result blocks. - Generate a changelog feed from
get_blog_postsfiltered to thereleasescategory, extracting title, date, and author from each post's frontmatter. - Render versioned Solidity reference pages in a custom IDE or editor by fetching
get_doc_pagewith the appropriateslugandversionslug. - Track when high-severity compiler bugs were introduced and fixed using the
introduced,fixed, andseverityfields fromget_known_bugs. - Monitor new security alerts by polling
get_blog_postswithcategory=security alertsand comparing returned post dates. - Enumerate all available compiler documentation versions with
list_doc_versionsto populate a version-picker UI.
| 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.
Does soliditylang.org have an official developer API?+
What does `get_bugs_by_version` return, and how is it different from `get_known_bugs`?+
get_known_bugs returns the full bug records — including description, severity, summary, introduced, and fixed — for every known compiler bug. get_bugs_by_version returns a version-keyed map where each entry lists only the bug names (as strings) and the released date for that compiler version. Use get_known_bugs when you need full bug detail, and get_bugs_by_version when you want a quick lookup of which bugs affect a given release.Can I retrieve the RST source for documentation pages?+
get_doc_page returns a source_rst field containing the raw reStructuredText source alongside content_html and the headings array. The get_documentation_home endpoint does not include RST source — it only returns toc, title, version, and content_html.Does the API expose Solidity compiler downloads, release artifacts, or changelogs in structured form?+
How do I find the right slug to use with `get_doc_page`?+
get_documentation_home first — it returns a toc array where each entry includes a slug, title, and href for every section in the documentation. Use those slugs directly as the slug parameter in get_doc_page.