API 登记簿

Exchange rates from central banks. We use v1: ECB only, 1999 to today, 30 currencies.

The keyless exchange-rate source worth building on: no signup, CORS open so a browser can call it directly, and history to 1999-01-04. Its failure modes are quiet rather than loud, which is the whole reason for an entry. First, a non-working day resolves BACKWARDS with a 200 — ask for a Sunday and you get Friday's rates with only the `date` field changed, so a consumer that echoes the requested date mislabels its own data. Second, every bad input is the same opaque `404 {"message":"not found"}`: unknown currency, pre-1999 date and future date are indistinguishable, so the client translates that one status into an error naming all three. Third, and the expensive one: cross rates are computed server-side and rounded, so how much precision survives depends on which way you ask. `base=USD` gives `JPY: 154.75`; the same pair as `base=JPY` gives `USD: 0.00646`, whose last digit is worth ~24x more relative to the value. At the extreme it is disqualifying: `base=IDR` gives `GBP: 4.2e-05`, last digit worth 2.4% of the rate. Always make the larger unit the base and divide. Do NOT quote a single precision figure from one reading, though — this verdict did, and was wrong by 10x for a day. JSON drops trailing zeros, so `0.00640` arrives as `0.0064` and any digit-counting measurement reads one decimal too few; the served digit count moves between readings and no `N decimals` or `N significant digits` rule fits all of it (0 to 6 decimals observed across nine bases). Treat every such figure as an upper bound and assert on the RATIO between directions, which is stable. Compare with the Treasury's own quarterly rate (see fiscaldata): same nominal quantity, different authority, and for US federal reporting the Treasury's is the one that counts. COMMERCIAL USE, since it is the first question anyone asks: yes, in three layers. The code is MIT and self-hostable, so the hosted instance's rate limit is optional. The hosted service says so outright — its FAQ answers "Yes, absolutely. See each provider's terms for details on the underlying data" — which hands the data licence back to you. And the ECB data v1 serves may be reused free of charge, commercially included, on two conditions: quote the source (their example is "Source: ECB statistics.") and do not modify the statistics or metadata. The trap is not the licence but the PURPOSE: the ECB states these rates are published for information only and that "using the rates for transaction purposes is strongly discouraged", so displaying, invoicing and reporting are fine while settling at that rate is not what they are for. The no-modification condition also collides with the rounding above — a server-computed cross rate is no longer the published figure — so the clean form is base=EUR plus your own arithmetic and your own attribution. And the version split matters here more than anywhere: v2's default blended rate draws on 84 providers of which only 29 publish a terms_url at all, so 55 of them come with unknown terms. Filter to a named provider, or stay on v1, before any of this is a commercial answer. Also worth knowing when the day comes to move: v2 fixes the opaque 404 — an unknown parameter is 422 naming it.

Federal debt, interest rates, cash flows and official exchange rates.

Authoritative, keyless, CORS-open, and it hides the nastiest trap in this registry so far: **`fields` silently deduplicates rows, and `total-count` agrees with the collapsed number.** Project `rates_of_exchange` to `record_date` alone and 18,981 rows become 102; `avg_interest_rates` goes 5,009 to 308. The rows are not truncated, they are merged once the distinguishing column is gone, and the metadata reports the merged count — so every average, sum and count taken over a projection is wrong, and nothing anywhere says so. Bandwidth-saving instinct is what triggers it. The fix generalises: `src_line_nbr` is the source row's position, present on every dataset, and with `record_date` it restores the full set exactly — verified on four datasets — so the client unions those two into every projection and the collapse becomes inexpressible. Two more shapes cost time. Every value is a string, dates and integers included, and a missing one is the four-character string `"null"` — not JSON null — so `Number()` yields NaN silently on 2,958 of the 8,386 rows in debt_to_penny (`debt_held_public_amt`), a third of that dataset, and on 28 of 5,009 in avg_interest_rates. It is a VALUE rather than an absence, and provably so: `filter=debt_held_public_amt:eq:null` selects exactly those 2,958 rows — which also means no value-based filter anywhere can treat it as missing. Meanwhile the columns a projection omits are ABSENT keys: three different ways to say "not here" in one API, which is why reading whole rows and reading a projection are two functions. Amounts are 16 significant digits and still round-trip through float64 exactly; the probe asserts that every run, so the day the debt gains a digit it goes red instead of shedding cents. Error messages are unusually good — they name the parameter and its bounds — so pass them through rather than replacing them with a status code.

Every US public filing, plus XBRL financial facts per company and market-wide.

First-party fundamentals with no key, no quota worth fearing and no paid tier in front of the good part — `frames` returns one concept for one period across 6,136 filers in a single response, which makes market-wide screening free. The entry exists for the gate in front of it. The SEC's page says to declare your tool in a User-Agent; what is actually enforced is a THREE-TIER DENYLIST, and reading the 403 at face value costs an afternoon. A header beginning with `curl` or `python-requests` is refused as a raw string prefix — `curly/1.0` too. `wget` and `java` are refused as whole words anywhere in the header, while `javascript` and `jakarta` pass. And `github.com`, `github.io`, `go-http-client`, `axios/` and `okhttp` are refused as substrings anywhere, `xxgithub.comxx` included. So the conventional courtesy — putting your repository URL in the User-Agent so the operator can reach you — is itself a 403, served with a page about undeclared automated tools, while `undici`, `PostmanRuntime` and Node's bare default `node` all pass. The rule enforced is "do not look like a bare library, and do not mention GitHub", not "declare yourself"; an empty header is the one part of the instruction that is real. Shapes cost the rest. `filings.recent` is COLUMNAR — sixteen parallel arrays where index i is one filing — resting on an equal-length invariant the vendor never states, so the schema checks it and transposes. Missing values split by type in the same record: `reportDate` is `""` on 228 of 1,000 rows while `isXBRLNumeric` is JSON null on 973. The same company's CIK is a zero-padded string in `submissions` and a bare number in `companyconcept`, so a naive join across the two endpoints matches nothing. And `companyfacts` is the wrong endpoint for one number: 3.6 MB and 505 tags for a company `companyconcept` answers in a few KB. One operational note, from the same afternoon: `data.sec.gov` publishes AAAA records, and on a network with global IPv6 addresses but no IPv6 egress, Node's default connect either waits ~6.5 s or fails with ETIMEDOUT while curl falls back in 100 ms — `net.setDefaultAutoSelectFamily(false)` fixes it and `dns.setDefaultResultOrder("ipv4first")` does not.

Wallpaper search — full-resolution images with dimensions and thumbnails.

Anonymous callers get almost everything: sfw AND sketchy are both open, and only the nsfw bit needs a key — which makes it the wallpaper source that can be a fallback with nothing to apply for. The trap is that the nsfw bit fails in silence. A keyless purity=001 returns 200 with meta.total 0, and in a mixed request it simply contributes nothing: keyless 111 and 110 come back with the identical total. No error, no warning, no hint that a third of what you asked for was dropped. That is the third failure mode in this registry — Openverse 401s, Iconify clamps into range, this one says nothing at all — so the client clears that one bit when keyless, and throws if nsfw was the only thing asked for. Do NOT over-correct by pinning everything to sfw: an earlier version of this entry did, on the strength of a first page that was all sfw, and that page was all sfw only because sfw outnumbers sketchy about 50:1 in sort order. Totals are the evidence; one page is not. A key also widens the sfw and sketchy pools themselves (12728 to 13615, 242 to 745 on the same query) — presumably account filters, not measured further. Page size is a fixed 24 (per_page is accepted and ignored), making pagination the only lever. Two shapes bite: meta.query is a plain string for a normal search but resolves to {id, tag} for an exact-tag search, and ratio is a string ("1.5"), not a number. The key can travel as an X-API-Key header instead of the ?apikey= query the docs lead with, which keeps it out of access logs. And it sends no Access-Control-Allow-Origin at all, so a browser cannot call it directly — every web client needs a server hop, which is where the key should live anyway.

Royalty-free photos and illustrations, permissively licensed.

No keyless mode, so it cannot be the fallback provider. The trap is the 500-result ceiling: it is a cap on what you can *reach*, not on what matched, so naive pagination walks confidently off the end. The original file needs full API access — a free key gets you roughly 1280px, which is fine for reference and not for print.

Creative-Commons and public-domain media aggregated from Flickr, Wikimedia and others.

Keyless, which makes it the provider that always works. Two things to design around: the page_size ceiling for anonymous callers is a hard 401 rather than a clamp, so a client that asks for 50 gets an error and not 20 rows; and because it aggregates upstreams, nearly every field is nullable — dimensions and file type routinely absent, so a schema without optionals fails on real data. It hands back a ready-made attribution string, which is the single most useful field any of these five return.

Curated stock photography, with a browsable default feed.

The key goes in an Authorization header, never a query param, so it cannot leak into a logged URL — the only one of the five that gets this right by design. Its nicest property is that an empty query has an answer: /curated is a real feed, so a search UI has something to show before anyone types. Pagination is a next_page URL that simply disappears on the last page rather than a count.

Search across 150+ open-source icon sets — 200k+ icons, as SVG.

Keyless and the matrix already leans on it twice over — yAssets imports from it, and every icon on every yPulse surface is one of its sets. Two facts worth carrying: results are monochrome SVGs using currentColor, so a thumbnail needs a colour applied or it renders invisible while the imported original stays recolourable; and licence and author are per *set*, returned in the response's collections map rather than on each icon, so an importer that reads only the icon loses the attribution it needs.

DNS records, zones, Workers and Pages deployment.

Carries the matrix's DNS convergence. The trap is not in the API but in what it lets you do: proxying a Vercel record breaks domain-control validation months later, and a Workers custom domain is created and owned by wrangler — writing it through this API means two systems fighting over one name. Scoped tokens are worth the extra minute; Zone:Read + DNS:Edit is all a converger needs.

Repository facts — commits, releases, traffic, contents, Actions dispatch.

The matrix's own nervous system: every snapshot, ledger and changelog yPulse shows is read through it. Two things to know before leaning harder on it — the traffic endpoints only return 14 days, so a collector that skips a fortnight loses that window forever, and the stats endpoints (code frequency) answer 202 with an empty body while GitHub computes, which reads as 'no data' unless you retry.

Daily launch leaderboards with topics, votes and maker data.

Feeds yPulse's radar. GraphQL, so the cost is complexity rather than call count — a wide query on one day beats many narrow ones. The day boundary is US-Pacific and not negotiable, which is why the collector names its files by that day instead of local time.

Text generation and structured extraction.

Two jobs in yPulse and they want opposite things: the weekly digest is long, tolerant and offline (a bad sentence costs nothing), while Discord's /c capture is short, interactive and must not lose data — so its parser re-validates with zod and falls back to filing the raw text as one idea. Any future use should decide which of those two it is before picking a model.

Slash commands over HTTP, plus one-way webhook posting.

The reason yPulse has a terminal without running a gateway process: HTTP interactions verify an Ed25519 signature per request, so a serverless route is enough. The 3-second acknowledgement is the design constraint — anything that calls an LLM has to defer (type 5) and finish in the background. Command choices are baked in at registration, so a change to the project list means re-running the register script.

Postgres over HTTP, with branching and scale-to-zero.

The hub's read-write side. The HTTP driver is what makes it fit a serverless route at all — a pooled TCP client would spend its life reconnecting. Scale-to-zero means the first query after a quiet period pays a cold start, which is fine for an operator tool and would not be for anything a visitor waits on.