Discover/Solidity Lang API
live

Solidity Lang APIsoliditylang.org

Access Solidity documentation pages, compiler versions, blog posts, and the known-bugs database via 8 structured endpoints from soliditylang.org.

Endpoint health
verified 6d ago
list_doc_versions
search_documentation
get_blog_posts
get_blog_post
get_bugs_by_version
8/8 passing latest checkself-healing
Endpoints
8
Updated
22d ago

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.

Try it
Documentation version slug (e.g. 'latest', 'stable', 'v0.8.35').
api.parse.bot/scraper/89f5632c-3505-4e24-b021-33e4a5ec8587/<endpoint>
Ready to send
Fill in the parameters and hit sign in to send to see live response data here.
Call it over HTTPgrab a free API key at signup
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'
Python SDK · recommended

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")
All endpoints · 8 totalmissing one? ·

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.

Input
ParamTypeDescription
versionstringDocumentation version slug (e.g. 'latest', 'stable', 'v0.8.35').
Response
{
  "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.

Reliability & maintenanceVerified

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.

Last verified
6d ago
Latest check
8/8 endpoints passing
Maintenance
Monitored & self-healing
Will this API break when the source site changes?+
It's built not to. Every endpoint is health-checked on a schedule with automated test probes. When the source site changes and a check fails, the API is automatically queued for repair and re-verified — that's the self-healing layer. Each API page shows when its endpoints were last verified. And because marketplace APIs are shared, any fix reaches everyone using it.
Is this an official API from the source site?+
No — Parse APIs are independent, managed REST wrappers over publicly available data. That is the point: where a site has no official API (or only a limited one), Parse gives you a maintained, monitored endpoint for that data and keeps it working as the site changes — so you get a stable contract over a source that never promised one.
Can I fix or extend this API myself if I need a new endpoint or field?+
Yes — and you don't have to wait on us. This API was generated by the Parse agent, which stays attached. Describe the change in plain English ("add an endpoint that returns reviews", "fix the price field") in the revise box on the API page or via the revise_api MCP tool, and the agent rebuilds it against the live site in minutes. Contributing the change back to the public API is free.
What happens if I call an endpoint that has an issue?+
Errors are machine-readable: a bad call returns a clean status with the list of available endpoints and a repair hint, so an agent (or you) can recover or trigger a fix instead of failing silently. Confirmed failures feed the automatic repair queue.
Common use cases
  • Audit a smart contract project by cross-referencing its compiler version against get_bugs_by_version to surface all known bugs affecting that release.
  • Build a documentation search tool for Solidity developers using search_documentation with version-scoped queries and highlighted result blocks.
  • Generate a changelog feed from get_blog_posts filtered to the releases category, 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_page with the appropriate slug and version slug.
  • Track when high-severity compiler bugs were introduced and fixed using the introduced, fixed, and severity fields from get_known_bugs.
  • Monitor new security alerts by polling get_blog_posts with category=security alerts and comparing returned post dates.
  • Enumerate all available compiler documentation versions with list_doc_versions to populate a version-picker UI.
Pricing & limitsSee full pricing →
TierPriceCredits/monthRate limit
Free$0/mo1005 req/min
Hobby$30/mo1,00020 req/min
Developer$100/mo5,000100 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.

Frequently asked questions
Does soliditylang.org have an official developer API?+
There is no official public REST or GraphQL developer API from the Solidity team. The documentation is published via ReadTheDocs and the bug database lives in a GitHub repository JSON file, both intended for human browsing rather than programmatic access. This Parse API provides structured, versioned access to that content.
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?+
Yes. 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?+
Not currently. The API covers documentation content, blog posts, and the bug database. Compiler binary metadata and release changelogs as discrete structured fields are not exposed. You can fork this API on Parse and revise it to add an endpoint targeting the Solidity GitHub releases or the compiler build list.
How do I find the right slug to use with `get_doc_page`?+
Call 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.
Page content last updated . Spec covers 8 endpoints from soliditylang.org.
Related APIs in Developer ToolsSee all →
docs.centrifuge.io API
Access comprehensive Centrifuge protocol information including documentation, pools, tokens, vaults, and investor data through intelligent search and navigation tools. Query transaction history, investment positions, and detailed protocol metrics across the Centrifuge ecosystem.
docs.opensearch.org API
Search OpenSearch documentation across multiple versions, retrieve specific page content, discover breaking changes, and navigate the docs structure all from a single interface. Instantly find answers by searching the docs or get a complete overview of available versions and site navigation.
a16zcrypto.com API
Access a16z Crypto's latest blog posts, portfolio companies, and team member information with powerful search and filtering capabilities. Get comprehensive details about their investments, team profiles, and company insights all in one place.
deepwiki.com API
Search and retrieve documentation for any GitHub repository indexed on DeepWiki, including wiki pages, table of contents, and source file references in markdown format. Look up repository profiles, discover featured projects, and access complete wiki content all in one place.
esp.ethereum.foundation API
Access information about Ethereum Foundation's grant programs, including open funding rounds, RFPs, and application details to find grants that match your project's needs. Browse blog posts, wishlist items, and office hours schedules to stay updated on ecosystem support opportunities.
docs.gl API
Access comprehensive OpenGL and GLES function documentation by searching across all versions, filtering by category, or looking up specific function details. Quickly find the exact graphics programming reference you need organized by function categories and API versions.
Docs.copia.io API
Search and browse the complete Copia Automation documentation, discover available pages, and retrieve full text content from any page on docs.copia.io. Quickly find answers by searching documentation content or accessing specific guides and references.
help.perforce.com API
Access detailed documentation and reference materials for Perforce Helix Core commands, including command syntax, client configuration options, form fields, and system configurables. Search through the complete P4 command reference to find specific commands, view their parameters, and understand client submission and line ending options.