SemiAnalysis APIsemianalysis.com ↗
Access SemiAnalysis newsletter posts via API. Retrieve article metadata, full HTML content, authors, tags, and engagement metrics for semiconductor and AI infrastructure analysis.
What is the SemiAnalysis API?
The SemiAnalysis API provides 2 endpoints to retrieve newsletter posts covering semiconductors, AI infrastructure, and datacenter technology. The list_posts endpoint returns paginated summaries including titles, authors, publication dates, word counts, and audience access levels, while get_post delivers the full HTML body, tags, and engagement metrics for any individual article by its URL slug.
curl -X GET 'https://api.parse.bot/scraper/9435a1cf-0868-4388-aeba-6123bdf2dca4/list_posts?limit=5&offset=0' \ -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 semianalysis-com-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: SemiAnalysis newsletter SDK — browse posts, drill into full content."""
from parse_apis.semianalysis_com_api import SemiAnalysis, InputNotFound
client = SemiAnalysis()
# List recent post summaries with a total-items cap.
for summary in client.post_summaries.list(limit=5):
print(summary.title, f"({summary.wordcount} words, {summary.reaction_count} reactions)")
# Drill down: take the first summary and navigate to its full detail.
summary = client.post_summaries.list(limit=1).first()
if summary is not None:
post = summary.details()
print(post.title)
print(post.subtitle)
print(f"Updated: {post.updated_at}")
print(f"Body preview: {post.truncated_body_text[:120]}")
for author in post.authors:
print(f" Author: {author.name} (@{author.handle})")
# Point lookup by slug derived from the listing.
if summary is not None:
try:
detail = client.posts.get(slug=summary.slug)
print(detail.title, detail.reaction_count)
except InputNotFound:
print("Post not found")
print("exercised: post_summaries.list / PostSummary.details / posts.get")
List SemiAnalysis newsletter posts in reverse chronological order with pagination. Returns metadata for each post including title, authors, date, description, engagement metrics, and cover image. Use offset and limit to paginate through the full archive.
| Param | Type | Description |
|---|---|---|
| limit | integer | Number of posts to return per page (1-100). |
| offset | integer | Number of posts to skip for pagination. |
{
"type": "object",
"fields": {
"limit": "integer, the limit used",
"posts": "array of post summary objects with id, title, slug, subtitle, post_date, audience, authors, description, cover_image, wordcount, reaction_count, comment_count",
"offset": "integer, the offset used"
},
"sample": {
"limit": 5,
"posts": [
{
"id": 209189055,
"slug": "kimi-k3-the-manos-the-mythos-the",
"type": "newsletter",
"title": "Kimi K3, The Manos, The Mythos, The Legendos",
"authors": [
{
"name": "Kimbo Chen",
"handle": "kimbobachen"
},
{
"name": "Dylan Patel",
"handle": "semianalysis"
}
],
"audience": "only_paid",
"subtitle": "Kimi K3’s architecture: compressed memory, attention across depth, latent expert routing, and serving performance",
"post_date": "2026-08-03T19:42:30.801Z",
"wordcount": 4744,
"section_id": null,
"cover_image": "https://substack-post-media.s3.amazonaws.com/public/images/872a94ce-6123-4a09-bb86-4f5aa363fece_1672x941.png",
"description": "Kimi K3’s architecture: compressed memory, attention across depth, latent expert routing, and the inference performance",
"canonical_url": "https://newsletter.semianalysis.com/p/kimi-k3-the-manos-the-mythos-the",
"comment_count": 0,
"reaction_count": 149
}
],
"offset": 0
}
}About the SemiAnalysis API
Endpoints Overview
The API exposes two endpoints. list_posts returns an array of post summary objects with fields including id, title, slug, subtitle, post_date, audience, authors, description, cover_image, and wordcount. Use the limit parameter (1–100) and offset parameter to paginate through the full archive in reverse chronological order. The audience field indicates whether a post is publicly available (everyone) or restricted to paid subscribers (only_paid).
Single Post Detail
get_post accepts a slug string — the URL path segment from the post's canonical URL — and returns full post data including body_html, tags, type, subtitle, authors (with name and handle per author), and post_date as an ISO 8601 timestamp. The body_html field contains the complete article HTML and may be null for posts where full content is not accessible. Slugs are obtainable from list_posts results, making the two endpoints straightforward to chain.
Coverage and Scope
SemiAnalysis publishes deep-dive research on semiconductor supply chains, chip architectures, AI accelerator deployments, and hyperscaler infrastructure. The API reflects the publication's archive as hosted on its Substack-powered platform. The audience field lets you identify open-access posts versus paid-only content before attempting to retrieve body content.
The SemiAnalysis API is a managed, monitored endpoint for semianalysis.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when semianalysis.com 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 semianalysis.com 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?+
- Monitor new SemiAnalysis posts on AI infrastructure by polling
list_postsand checkingpost_datefor recent publications. - Build a semiconductor research digest by extracting
title,subtitle, anddescriptionfields fromlist_postsresults. - Filter open-access content by checking the
audiencefield before fetching full articles viaget_post. - Index SemiAnalysis articles into an internal knowledge base using
body_htmlfromget_postfor search and retrieval. - Track author contributions by parsing the
authorsarray (name and handle) across paginatedlist_postsresponses. - Aggregate topic coverage by collecting
tagsfrom individualget_postresponses to identify frequently covered themes. - Estimate reading load for a content pipeline using the
wordcountfield returned inlist_postssummaries.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does SemiAnalysis have an official developer API?+
What does the `audience` field in `list_posts` tell me?+
everyone (the post is publicly accessible) or only_paid (restricted to paid subscribers). You can use this field to filter results before calling get_post, since body_html may be null for paid-only posts.How does pagination work in `list_posts`?+
limit (1–100 posts per page) and offset (number of posts to skip). Both values are echoed back in the response alongside the posts array. To walk the full archive, increment offset by your chosen limit on each request until fewer results than limit are returned.Does the API expose reader comments or subscriber counts for posts?+
Can I search posts by keyword or filter by tag?+
list_posts returns posts in reverse chronological order and supports only limit and offset for pagination. Tag data is available per post via get_post, but there is no server-side tag or keyword filter. You can fork this API on Parse and revise it to add a search or tag-filter endpoint.