# OpenAPI to LLM Tools & Function Calling (`awesome_highboy/openapi-llm`) Actor

Convert any OpenAPI/Swagger spec into per-endpoint LLM tool definitions (function calling schemas) plus clean Markdown docs. Generates JSON-schema tools ready for OpenAI, Claude/Anthropic, and any agent framework. Paste a spec URL or inline JSON; deterministic, content-hashed output per endpoint.

- **URL**: https://apify.com/awesome\_highboy/openapi-llm.md
- **Developed by:** [Adam](https://apify.com/awesome_highboy) (community)
- **Categories:** Developer tools, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 endpoint processeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 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.

# Actor input Schema

## `specUrl` (type: `string`):

URL to an OpenAPI/Swagger JSON spec you own or are authorized to use.

## `spec` (type: `object`):

OpenAPI spec (inline JSON)

## `ownership_attestation` (type: `boolean`):

I own/am authorized to use this spec (REQUIRED)

## Actor input object example

```json
{
  "ownership_attestation": false
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("awesome_highboy/openapi-llm").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("awesome_highboy/openapi-llm").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call awesome_highboy/openapi-llm --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=awesome_highboy/openapi-llm",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/NbaU4RCrH9rKEiNwQ/builds/BgCpXK1i7DnmUr3ZP/openapi.json