# LAP - Every API, Ready for AI

## Navigation
Registry | Format | Playground | Skills | Browse APIs

---

## Hero

Lean API Platform

Every API, ready for AI.

10x smaller API specs. Agents run 35% cheaper and 29% faster on LAP specs. Verified across 500 benchmark runs.

100% open source.

---

## The Registry

1,389 APIs. Pre-compiled. Ready to use.

Every spec in the registry is already compiled to LAP format. Search, download, and feed directly to your agent.

Featured APIs:
- Stripe: 327 endpoints, 81% smaller
- GitHub: 930 endpoints, 79% smaller
- Slack: 174 endpoints, 74% smaller
- Discord: 103 endpoints, 76% smaller
- Twilio: 278 endpoints, 72% smaller
- OpenAI: 68 endpoints, 77% smaller
- Cloudflare: 531 endpoints, 83% smaller
- Spotify: 94 endpoints, 75% smaller
- Anthropic: 12 endpoints, 69% smaller
- SendGrid: 156 endpoints, 78% smaller
- +1,370 more in the full registry

---

## The Format

One structured output. Five spec formats in.

Built for agents, not humans. LAP strips prose, collapses boilerplate, and produces a structured contract your agent can parse and act on immediately.

### OpenAPI Spec (Verbose, human-oriented)

Create a Payment Intent

A PaymentIntent guides you through the process of collecting a payment from your customer. We recommend that you create exactly one PaymentIntent for each order or customer session in your system...

POST /v1/payment_intents

Parameters:
amount (required) - Amount intended to be collected. A positive integer representing how much to charge in the smallest currency unit (e.g., 100 cents to charge $1.00)...
currency (required) - Three-letter ISO code
payment_method_types (optional) - The list of payment method types that this PI is allowed to use. If not provided, defaults to...

### LAP Format (Structured, agent-native)

@endpoint POST /v1/payment_intents
@desc Create a payment intent
@required {amount: int, currency: iso4217}
@optional {payment_method_types: [str]}
@returns(200) {id: str, amount: int, status: str}
@errors {400, 401, 402}

### Compiles from any format
- OpenAPI: 3.x and Swagger 2.0
- Postman Collections: Collections v2.x
- AsyncAPI: Event-driven APIs
- Protobuf: Protocol Buffers
- GraphQL SDL: Schemas and introspection

---

## Playground

Paste any API spec. See LAP output instantly.

Supported input formats: OpenAPI (YAML), OpenAPI (JSON), Postman Collection, AsyncAPI, GraphQL SDL, Protobuf.

The playground compiles specs via POST https://registry.lap.sh/v1/compile and shows original vs. LAP token counts with reduction percentage.

---

## Skills

From spec to agent skill in one command.

Skills wrap a LAP spec with auth setup, question routing, and execution playbooks. Your agent gets everything it needs to call any API, out of the box.

Built for: Claude Code, OpenClaw (coming soon).

Command: lapsh compile stripe-com --skill

### Example Skill Output

@skill stripe-com
@version 2024-12-01

@auth
  type: bearer
  header: Authorization
  env: STRIPE_API_KEY

@questions
  "charge a customer" -> POST /v1/payment_intents
  "list all subscriptions" -> GET /v1/subscriptions
  "refund a payment" -> POST /v1/refunds

@hints
  Amounts are in cents (e.g., $10.00 = 1000)
  Currency uses ISO 4217 lowercase (e.g., "usd")

@playbook
  1. Read @auth and set up authentication
  2. Match user intent to @questions
  3. Look up endpoint in the LAP spec
  4. Build request with @required params
  5. Execute and return structured response

### Skill Components

Auth setup: Declares auth type, header, and env variable. Your agent knows how to authenticate before making a single call.

Question routing: Maps natural language intents to specific endpoints. No prompt engineering needed.

Playbook generation: Step-by-step execution instructions so your agent can go from intent to API call without guessing.

---

## The CLI

Three commands. That's it.

1. Compile: $ lapsh compile api.yaml
   Turn any API spec into a structured LAP file your agent can read.

2. Generate skill: $ lapsh compile api.yaml --skill
   Add auth, question routing, and playbooks on top of the compiled spec.

3. Publish: $ lapsh publish api.lap
   Share your compiled spec with the community via the public registry.

Install: npm install -g @lap-platform/lapsh

---

## Comparison: Why not just use raw specs?

| Aspect              | Raw API Specs               | Hand-written Skills      | LAP                    |
|---------------------|-----------------------------|--------------------------|------------------------|
| Setup time          | None, but agent struggles   | Hours per API            | One command            |
| Structure           | Prose-heavy, variable       | Custom per author        | Consistent, typed      |
| Scalability         | Copy-paste per API          | Manual per API           | 1,389 APIs ready       |
| Auth handling       | Implicit                    | Manual                   | Declarative            |
| Agent readability   | Low                         | Varies                   | Optimized              |
| Maintenance         | Specs drift                 | Manual updates           | Re-compile anytime     |

---

## FAQ

**What is LAP?**
LAP (Lean API Platform) is a structured format that makes any API instantly usable by AI agents. It compiles existing API specs (OpenAPI, Swagger, HTML docs, or raw URLs) into a compact, agent-native representation that cuts token usage by up to 88%.

**How is LAP different from OpenAPI?**
OpenAPI is designed for humans and tooling. LAP is designed for AI agents. A typical OpenAPI spec might use thousands of tokens to describe an endpoint; LAP compresses the same information into a fraction of that while preserving everything an agent needs to make the call. You can think of LAP as a compilation target, not a replacement.

**What input formats does LAP support?**
The compiler accepts OpenAPI 3.x, Swagger 2.0, raw HTML documentation pages, and direct API URLs. If it describes an HTTP API, LAP can probably compile it.

**Is LAP open source?**
Yes. The format spec, CLI, and compiler are all open source under Apache 2.0. The registry is free to use and the compiled outputs are free to redistribute.

**Do I need to modify my API to use LAP?**
No. LAP works with your API as-is. Point the compiler at any existing spec or docs page and it generates a LAP file. No server changes, no SDK, no integration required.

**What are Skills?**
Skills are curated bundles of related API endpoints grouped by task, for example "send a message" or "create an invoice". They let agents load only the capabilities they need instead of an entire API surface, which further reduces token usage and improves accuracy.

**How do I get started?**
API providers: run `lap compile` on your spec to generate a LAP file, then publish it to the registry so agents can discover your API. Developers: add skills from the plugin marketplace with lap-platform/claude-marketplace, ask your agent to browse the registry, or download and point to any spec directly. Agent frameworks: fetch LAP files from the registry at runtime and feed them directly into your model's system prompt or tool definitions.

**Are the APIs in the registry verified?**
About 3% of registry entries are community-flagged and labeled as such. Flagged APIs have been reviewed for general correctness and auth documentation. All other entries are compiled automatically and may contain gaps.

**Is LAP free?**
Yes. The CLI, compiler, format spec, and public registry are all free. There are no paid tiers, usage fees, or premium features.

**Where do the benchmark numbers come from?**
The headline stats (88% fewer tokens, 35% cheaper, 29% faster) come from 500 standardized benchmark runs comparing LAP-compiled output against raw OpenAPI specs across a diverse set of real-world APIs. The methodology and raw data are published in the project's GitHub repository.

**Can I run LAP privately?**
Yes. The CLI and compiler run entirely on your machine. You can compile specs locally, store the output wherever you like, and never touch the public registry. For teams, you can host a private registry instance.

**How can I contribute?**
Contributions are welcome. You can verify registry entries, submit new API compilations, improve the compiler, or propose changes to the format spec. Everything lives in the Lap-Platform GitHub org.

---

## Footer

Lean API Platform

Product: Format | Registry | Skills | Playground
Developers: CLI Docs | Spec Reference | Browse APIs
Community: GitHub | Discussions | Apache 2.0 License

Lean API Platform (c) 2025-2026