OpenAPI to LLM Markdown + Tool Defs

Convert an OpenAPI/Swagger spec into clean per-endpoint Markdown docs and ready-to-use agent tool-call definitions.

What it does

Give the Actor an OpenAPI/Swagger spec (inline JSON or a URL) and it walks every path and HTTP method (get, post, put, patch, delete, options, head) in the spec. For each operation it produces two things:

• A clean Markdown doc for that endpoint — method, path, operationId, summary, a parameter list (name, type, required flag, description) and the set of response status codes.
• An agent tool-call definition — a name, a description, and a JSON-Schema-style parameters object (type: object, properties, required) built from the operation's path/query parameters and its application/json request-body fields.

Parameters are collected from both path-level and operation-level parameters, plus the JSON request body. When an operation has no operationId, a deterministic one is derived from the method and path. When a field has no declared type, it falls back to string; when an operation has no summary, the tool description falls back to METHOD /path. Descriptions and summaries are passed through from the spec as written — the Actor does not invent or rewrite API semantics.

Every emitted record includes a deterministic content_hash (sha256:<64 hex>), so identical input always yields identical hashes — convenient for caching, diffing, and idempotent downstream pipelines.

Input

Field	Type	Required	Description
ownership_attestation	boolean	Yes	You confirm you own or are authorized to use this spec. Must be true or the run is rejected before any work, with zero billing.
specUrl	string	No	URL to an OpenAPI/Swagger JSON spec you own or are authorized to use.
spec	object	No	The OpenAPI spec inline as JSON.

Provide either spec (inline JSON) or specUrl. If spec is absent, the Actor fetches specUrl and parses it as JSON.

Output

Records are pushed to the dataset. Every record has a record_type of endpoint_doc, tool_def, or run_summary.

endpoint_doc — one per parsed operation:

• method — HTTP method, uppercased
• path — the path template
• operationId — declared or deterministically derived
• summary — the operation summary/description from the spec
• markdown — the rendered Markdown doc
• content_hash — sha256: hash of the Markdown

tool_def — one per generated tool definition:

• name — the operationId
• description — summary (or METHOD /path fallback), capped at 1024 chars
• parameters — JSON-Schema-style object (type, properties, required)
• content_hash — sha256: hash of the parameters

run_summary — one per run:

• spec_title, spec_version — pulled from the spec's info
• endpoints_processed — number of operations parsed
• tools_emitted — number of tool definitions generated

Pricing

This Actor uses Apify Pay-Per-Event:

Event	Price (USD)	When it fires
actor_run_start	$0.04	Once per run, after the gates pass
endpoint_processed	$0.0015	Per OpenAPI operation parsed into Markdown
tool_def_emitted	$0.0008	Per agent tool-call definition generated

Example run cost — a spec with 40 operations (so 40 endpoint docs and 40 tool defs):

• actor_run_start: 1 x $0.04 = $0.04
• endpoint_processed: 40 x $0.0015 = $0.06
• tool_def_emitted: 40 x $0.0008 = $0.032
• Total: $0.132

A run that is rejected at the ownership gate, or that runs on a non-paid plan, is billed $0.00.

Why this Actor

• Deterministic and idempotent. Parsing is pure and crypto-only; each record carries a reproducible sha256 content_hash, so re-running the same spec produces byte-identical output and stable hashes for caching and diffing.
• Ownership attestation gate. The run is rejected before any processing or billing unless you attest you own or are authorized to use the spec. Default-deny on free plans, too.
• No invented semantics. Summaries, descriptions, parameter names and types come straight from your spec. Missing values fall back to safe defaults (string type, METHOD /path description) rather than being hallucinated.
• Agent-ready output. The tool definitions are emitted in the JSON-Schema { name, description, parameters } shape that LLM tool-calling expects, and each endpoint gets its own self-contained Markdown doc.

About

This Actor is AI-authored and operated under the publisher's LLC. It bills only via Actor.charge(), which charges the customer for the Pay-Per-Event events above — the Actor contains no payout or money-out capability of any kind.