Craft APIbaths-matter-31q.craft.me ↗
Extract structured blocks, outbound links, deadlines, and file attachments from any shared Craft.me page. 4 endpoints, no Craft account required.
What is the Craft API?
This API exposes 4 endpoints for reading shared Craft.me documents, returning structured block arrays, outbound link inventories, deadline extractions, and file/priority listings. The get_page_content endpoint retrieves every block in a document with its type, text content, style, and link URL. The get_project_links endpoint separates internal Craft doc references from external URLs, making it straightforward to traverse a network of linked Craft pages.
curl -X GET 'https://api.parse.bot/scraper/fc2cfbb6-2f5c-425c-82bd-69e3c2b766bd/get_page_content?doc_id=HyTSKUmfIFOj2c' \ -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 baths-matter-31q-craft-me-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.
from parse_apis.craft_me_page_scraper_api import CraftMe
craft = CraftMe()
# Fetch structured page content
page = craft.pages.get(doc_id="HyTSKUmfIFOj2c")
print(page.doc_id, page.document_id, page.schema_version)
for block in page.blocks:
if block.content:
print(block.id, block.type, block.content[:80])
# Get all project links from a page
link_report = craft.linkreports.get(doc_id="HyTSKUmfIFOj2c")
print(link_report.total_links)
for link in link_report.craft_project_links:
print(link.text, link.url, link.craft_doc_id)
for ext in link_report.external_links:
print(ext.text, ext.url)
# Extract deadlines
deadline_report = craft.deadlinereports.get(doc_id="HyTSKUmfIFOj2c")
for deadline in deadline_report.deadlines:
print(deadline.text, deadline.due_date, deadline.block_id)
for item in deadline_report.upcoming_items:
print(item.text, item.block_id)
# Get key resources (files and priorities)
resources = craft.resourcereports.get(doc_id="HyTSKUmfIFOj2c")
for f in resources.files:
print(f.file_name, f.file_extension, f.mime_type, f.section)
for p in resources.priorities:
print(p.type, p.text, p.subject, p.link)
Fetches the full structured content of a shared Craft.me page. Returns all document blocks with their type, text content, style, link URLs, and child block IDs. Each block represents a content element (text, image, file, etc.) in the document hierarchy.
| Param | Type | Description |
|---|---|---|
| doc_id | string | The share document ID from the Craft.me URL path (e.g. 'bvNTUoCQxN4sF9' from craft.me/s/bvNTUoCQxN4sF9). |
{
"type": "object",
"fields": {
"blocks": "array of block objects with id, type, content, style_text, has_link, link_url, child_block_ids",
"doc_id": "string, the share document ID that was queried",
"space_id": "string, the workspace/space UUID",
"document_id": "string, the internal UUID of the document",
"schema_version": "string, schema version number"
},
"sample": {
"data": {
"blocks": [
{
"id": "4CF5F961-23DB-4642-9E5C-5579C3D28DD8",
"type": "text",
"content": "",
"has_link": false,
"link_url": null,
"style_text": "pageRegular",
"child_block_ids": [
"709D152A-9A53-453F-95B4-640970FACB9F"
]
}
],
"doc_id": "HyTSKUmfIFOj2c",
"space_id": "c84038f5-d15c-66d3-29f3-09be0a5e7200",
"document_id": "38C0B0CB-B05E-492C-BE31-1AFD9C276B96",
"schema_version": "1"
},
"status": "success"
}
}About the Craft API
Document Blocks and Structure
The get_page_content endpoint accepts a doc_id — the path segment from a shared Craft.me URL — and returns a flat array of block objects. Each block carries an id, type, content string, style_text, has_link flag, link_url, and a child_block_ids array for reconstructing the document hierarchy. Alongside the blocks, the response includes space_id, document_id, and schema_version for identifying the exact workspace and schema in use.
Links and Cross-Document Navigation
get_project_links processes the same doc_id input and returns two separate arrays: external_links (third-party URLs with their anchor text and originating block_id) and craft_project_links (Craft-internal URLs, each optionally carrying an extracted craft_doc_id you can pass directly to other endpoints). The total_links field gives a quick count across both arrays.
Deadlines and Upcoming Items
get_deadlines scans block content for date patterns and keywords like "due", and also looks for blocks nested under headings that match an "Upcoming Deadlines" pattern. Results come back as two arrays: deadlines (with text, due_date, and block_id) and upcoming_items (with text and block_id). The endpoint documentation notes that content using the word "due" in a non-date context can appear in results — downstream filtering on due_date presence helps reduce noise.
Files and Priorities
get_key_resources returns two arrays. The files array lists every attached file found in the document, with file_name, file_extension, mime_type, section, and block_id. The priorities array surfaces blocks identified as current project guides or active tasks, each tagged with a type (project_guide or current_task), the text content, a subject label, and an optional link.
The Craft API is a managed, monitored endpoint for baths-matter-31q.craft.me — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when baths-matter-31q.craft.me 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 baths-matter-31q.craft.me 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?+
- Mirror a shared Craft.me project hub into an external task tracker by consuming
get_deadlinesoutputs - Build a link graph of interconnected Craft documents using the
craft_doc_idvalues fromget_project_links - Inventory all PDF and document attachments across a Craft workspace page using
get_key_resourcesfile objects - Sync current priorities and project guides into a team dashboard by polling
get_key_resourcespriorities - Render a read-only view of a Craft document in a custom interface using
get_page_contentblock hierarchy - Alert on approaching deadlines by monitoring
due_datefields returned byget_deadlines - Catalogue all external references cited in a Craft doc using the
external_linksarray fromget_project_links
| 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 Craft.me offer an official developer API?+
What does `get_page_content` return beyond the text of each block?+
id, type, style_text, a has_link boolean, the link_url if present, and a child_block_ids array. That last field lets you reconstruct parent-child nesting without additional calls.Can `get_deadlines` reliably parse all date formats in a Craft document?+
due_date is non-null reduces noise, but unusual date formats or informal phrasing may not be captured.Does the API access password-protected or private Craft documents?+
Does the API support paginating through large documents with many blocks?+
get_page_content returns all blocks in a single response without pagination parameters. Very large documents return all block objects at once. You can fork the API on Parse and revise it to add cursor-based or offset pagination if you need to handle documents with a high block count incrementally.