Zenning APIzenning.ai ↗
Access Zenning AI's public pages via API. List all sitemap pages or fetch full content—titles, headings, text, links, and images—from any individual page.
What is the Zenning API?
The Zenning AI API exposes 2 endpoints that give structured access to every public page on zenning.ai. Use list_pages to enumerate the full sitemap with paths, sections, slugs, and depth, or call get_page with any site-relative path to retrieve that page's title, meta description, H1, ordered headings, paragraph text, internal and external links, and images in a single response.
curl -X GET 'https://api.parse.bot/scraper/35db3411-8773-44e6-90ec-50bc70f8d4e6/list_pages?section=%2Ffeatures%2Fapp-directory' \ -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 zenning-ai-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: Zenning AI website content API — browse the sitemap, then read a page."""
from parse_apis.zenning_ai_api import ZenningAI, PageNotFound
client = ZenningAI()
# List pages in the "features" section of the site.
for summary in client.page_summaries.list(section="features", limit=5):
print(summary.path, summary.section, f"depth={summary.depth}")
# Drill into the first page to get its full content.
summary = client.page_summaries.list(section="use-cases", limit=1).first()
if summary is not None:
page = summary.details()
print(page.title, f"({page.word_count} words)")
# Inspect headings hierarchy
for heading in page.headings[:5]:
print(f" h{heading.level}: {heading.text}")
# Show internal links
for link in page.links:
if link.internal:
print(f" -> {link.text}: {link.url}")
# Direct point-lookup by path discovered from the listing above.
try:
pricing = client.pages.get(path="/pricing")
print(pricing.h1, pricing.meta_description)
print(f"{len(pricing.images)} images, {len(pricing.paragraphs)} paragraphs")
except PageNotFound:
print("page not found")
print("exercised: page_summaries.list / PageSummary.details / pages.get")
Returns every public page of the site as listed in its sitemap, one row per page, in sitemap order (roughly alphabetical by path). Each row carries the site-relative path (no trailing slash; the home page is '/'), the absolute URL, the top-level section (e.g. features, use-cases, company, user-guides, compare), the final slug and the depth. An optional section path prefix restricts the rows to that subtree (e.g. use-cases, or features/app-directory for the ~130 integration pages); total is the row count after filtering and site_total is the whole-site page count. A prefix that matches nothing yields an empty pages array. One round trip to the sitemap index plus one per sitemap file (currently one); ~200 pages.
| Param | Type | Description |
|---|---|---|
| section | string | Site path prefix to filter by, with or without a leading slash, e.g. use-cases or /features/app-directory. Omitted = all pages. |
{
"type": "object",
"fields": {
"pages": "array of page rows: path (site-relative, feeds get_page), url, section (top-level path segment, 'home' for /), slug, depth (number of path segments)",
"total": "number of rows returned after the section filter",
"site_total": "number of distinct pages in the whole sitemap"
},
"sample": {
"data": {
"pages": [
{
"url": "https://zenning.ai/use-cases/customer-support",
"path": "/use-cases/customer-support",
"slug": "customer-support",
"depth": 2,
"section": "use-cases"
},
{
"url": "https://zenning.ai/use-cases/data",
"path": "/use-cases/data",
"slug": "data",
"depth": 2,
"section": "use-cases"
}
],
"total": 8,
"site_total": 208
},
"status": "success"
}
}About the Zenning API
Sitemap Enumeration
The list_pages endpoint returns every public URL in the zenning.ai sitemap as a structured array. Each row includes the site-relative path (e.g. /features/app-directory), the absolute url, the top-level section (with the home page returning 'home'), a slug, and a depth integer representing how many path segments deep the page sits. An optional section filter accepts a path prefix—with or without a leading slash—to narrow results to a specific subtree such as use-cases or /features. Two count fields, total and site_total, let you distinguish filtered results from the full sitemap size.
Page Content Extraction
The get_page endpoint accepts a single required path parameter—exactly as returned in list_pages—and returns the full extracted content of that page. The response includes the document title, meta description, Open Graph og_image, robots directive, canonical URL, the h1, and an ordered headings array covering levels 1 through 4. Body content is available both as raw text (newline-separated visible text) and as a links array where each entry carries the link text, destination URL, and an internal boolean indicating whether the link stays within zenning.ai. Any images in the main content are returned as an images array with src and alt fields.
Navigating the Content Structure
The depth field from list_pages is useful for scoping to top-level sections versus deep nested pages. Because path values feed directly into get_page, a common pattern is to call list_pages with a section filter first, collect the path values of interest, and then fetch each page individually with get_page. The section value on each row is always the first path segment, making it straightforward to group pages by product area.
The Zenning API is a managed, monitored endpoint for zenning.ai — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when zenning.ai 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 zenning.ai 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?+
- Index all zenning.ai feature and use-case pages to build a searchable knowledge base about the product.
- Extract headings and paragraph text from each page to generate structured summaries for competitive research.
- Collect all internal links from
get_pageresponses to map the site's navigation and content hierarchy. - Pull Open Graph titles and images from individual pages for social preview or content aggregation purposes.
- Filter
list_pagesby a section prefix (e.g.use-cases) to enumerate topic coverage for a specific product area. - Monitor the
site_totalcount over time to detect when new pages are added to the sitemap. - Retrieve meta descriptions and canonical URLs across all pages for SEO auditing or content gap analysis.
| 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 Zenning AI provide an official developer API?+
What does the `section` filter on `list_pages` actually match?+
features returns only pages whose path starts with /features/. The home page (/) maps to the section value 'home' and is not matched by any non-empty prefix. The filter accepts the prefix with or without a leading slash.Does `get_page` return content from behind a login or from dynamic JavaScript-rendered sections?+
Can I get structured data like pricing tables or feature comparison matrices from individual pages?+
get_page response includes headings, text, and links, so tabular content from a pricing or comparison page would appear in the text field as newline-separated visible text rather than as parsed rows or columns. You can fork this API on Parse and revise it to add an endpoint that extracts and normalises table data from specific pages.Is there pagination on the `list_pages` response?+
total field in the response tells you how many rows are included after any section filter, and site_total reflects the full sitemap count regardless of the filter applied.