What an AirnodeHub signature proves, and what it doesn't
Every successful response carries a signature over the request, the time and the exact bytes returned. Here is how to check one and where its guarantee ends.
Every successful response from an Airnode on AirnodeHub is an attestation: the upstream data plus a signature that binds it to the Airnode that served it, the request it answers and the moment it was signed. Airnode 0.2.0 tightens what that signature covers, so this is a good moment to spell out what it proves.
The five fields
{
"airnode": "0xE70f1e8b22a21e4Bb5188918a3033341b281E4c0",
"requestHash": "0x…",
"timestamp": "1752580000",
"data": "{\"ETH/USD\":{\"value\":1877.62,\"timestamp\":1752579990000,\"category\":\"crypto\"}}",
"signature": "0x…"
}
airnodeis the address that signed.requestHashidentifies the request, derived from the operation and its parameters in a fixed order.timestampis when it was signed, in unix seconds.datais the upstream body exactly as received, as one string.signaturecovers all three of the request hash, the timestamp and the data.
A passthrough response carries the same values in X-Airnode-* headers, with the body as data.
What it proves
Who answered. The signature recovers to one address, and the listing on AirnodeHub ties that address to a provider.
Which request. A response cannot be presented as the answer to a different request, because the request hash would no longer match. Parameter order does not change it, and through the passthrough it covers the query in the order it was sent and the header parameters that select what the upstream returns.
When. The timestamp is signed, so an old answer cannot be passed off as a new one.
Which bytes. Since 0.2.0 the Airnode signs the upstream body as it arrived, without parsing and rewriting it. A
price of 0.00000071234 stays exactly that, and an integer larger than JavaScript can hold keeps every digit.
Check one yourself
The signature is an EIP-191 signature, the same format every Ethereum wallet
uses for personal_sign, so ordinary tooling verifies it. With viem:
import { encodePacked, keccak256, toHex, verifyMessage } from 'viem';
const digest = keccak256(encodePacked(['bytes32', 'uint256', 'bytes'], [requestHash, BigInt(timestamp), toHex(data)]));
const valid = await verifyMessage({ address: airnode, message: { raw: digest }, signature });
Hash data as the string it arrived as and parse it only to read it. Take the expected address from the x-airnode
section of the document the Airnode serves at GET /, not from the response itself.
There is deliberately no verify endpoint. An Airnode grading its own work would prove nothing, so the check stays with you. Every listing's page on Explore runs the same check in the browser if you want to try it on a pasted response.
What it does not prove
That the upstream was right. A signature shows what the Airnode received and passed on. It does not make the provider's data accurate.
That the producer signed it. A listing marked first-party is operated by the data source itself, so the signature reaches the producer. Any other listing is a relay over a source it does not own, and the signature is provenance for the relay. Check which one you are calling.
That it is fresh enough for you. The timestamp tells you when it was signed. How old is too old is your rule to set and enforce.
That it has not been used before. The same answer to the same request verifies every time. If your application pays out or records something once per answer, keep track of the answers it has already accepted.
Keep the evidence
Keep each attestation whole, exactly as it came, beside the request you sent. An answer your agent assembles from several listings can carry every source attestation along, so whoever consumes it can check each source rather than trusting the last step.
Attestation documents the full algorithm, including the passthrough form and projections.