Airnode

Airnode turns an existing API into a listable, billable, verified endpoint.

It is the attestation service an API provider deploys. It runs alongside the existing business rather than replacing it: the provider keeps their customers, their pricing and their brand, and gains a distribution channel that was not there before.

What it does for a provider

An API provider has five jobs. They manage the data, define an interface for consumers, handle monetization, handle marketing, and attest to what they serve. Managing the data is their core value and is unavoidable. The rest is interface work, payment work and discovery work.

The fifth job is the one almost nobody does, and it is the one that cannot be delegated. Attestation is what separates a provider's data from a copy of it. Airnode does it on the provider's behalf while leaving the signature theirs, which makes them a full first-party data source. Attested data covers why that signature is the primitive everything else builds on.

How it works

Airnode is deliberately a tight wrapper. It assumes the API it wraps is HTTP based and takes the provider's own OpenAPI description of it as the whole configuration. There is no Airnode-specific mapping language between a caller and the upstream: what the document declares is what the Airnode serves, and nothing else.

On top of the wrapped API, an Airnode adds exactly two things. It describes itself, so an agent can discover what it serves without a human in the loop, and it signs every response, so the data carries proof of who produced it.

• Wrapping an API covers how the OpenAPI document becomes the configuration and how upstream credentials are supplied.
• The HTTP interface covers the two endpoints an Airnode serves and the document it publishes about itself.
• Attestation covers the signing algorithm and how a consumer verifies a response.

A deployed Airnode is called an integration: the OpenAPI document of one API, plus whatever bespoke behaviour that API needs, which is usually none.

Status

The pull model works end to end: an Airnode reads the OpenAPI description of an API, serves its own documentation, performs requests and signs the responses, authenticating to an upstream that wants a key. There is no payment and no polling module yet.

Nothing meters or bounds what a caller spends, which is only free of consequence while an upstream is. An integration over a paid API bills whoever deployed it, and both metering and bounding wait on payments.