Design APIs that feel like functions
A minimal, flexible specification for building APIs that are intuitive, discoverable, fun to use, and feels like calling functions in your favorite programming language.
For API designers
- • Focus on functionality, not HTTP (or REST) semantics
- • Self-documenting endpoints through packages
- • Flexible error handling with standardized triples
- • Built-in support for authentication and pagination
- • No complex routing or resource modeling required
For API consumers
- • Discoverable APIs with automatic documentation
- • Consistent error handling across all endpoints
- • Simple authentication with bearer tokens
- • Intuitive pagination that works like magic
- • Predictable request/response patterns
Core features
Simple endpoint design
Only POST requests. No complex HTTP method semantics. Just call the function with your data and get results back. The path names the action, the body carries the data.
Learn about endpoints →Self-documenting packages
Every API can describes all its available endpoints, their arguments, return types, and documentation via package definition. No more guessing or reading external docs.
Learn about packages →Standardized error handling
Error triples provide consistent, machine and human readable error responses. No more parsing different error formats across different endpoints.
Learn about error handling →Built-in authentication
Bearer token authentication that works consistently across all protected endpoints. The specification focuses on token passing, how you obtain the token is up to you.
Learn about authentication →Smart pagination
Strategy-agnostic pagination that works with cursors, offsets, or any other method. The server handles the complexity, clients just follow the links.
Learn about pagination →Benefits for your team
Faster development
Spend less time on API design decisions and more time building features. The specification handles the common patterns so you can focus on what matters.
Better experience
APIs that feel intuitive and predictable. Self-documenting packages mean less time reading docs and more time coding.
Consistent & reliable
Standardized patterns mean fewer bugs and easier maintenance. Error handling, auth, and pagination work the same everywhere.
Get started
Ready to build better APIs? Start with the core endpoint specification and then explore the extensions that make Web Function powerful.
Endpoint specification
Learn the core principles of Web Function endpoints and how to design them.
Read specification →Package documentation
Discover how packages make your APIs self-documenting and discoverable.
Read specification →Error handling
Standardize error responses with error triples for consistent client handling.
Read specification →Authentication
Simple bearer token authentication that works across all your endpoints.
Read specification →Pagination
Smart pagination that works with any strategy - cursors, offsets, or custom methods.
Read specification →Already built something with Web Function?
If you've created a client library or API using Web Function, we'd love to hear about it! Share your implementation and help grow the ecosystem.
Send us an email