Free · MIT-licensed · nothing phones home

The API connectors SDKs never shipped.

Owned, audited clients for Go, Python, and Node — for the thousands of APIs that never had an SDK in your language, and for agents that need tools without handing a middleman your keys.

npx verifyport add notion

See the proof →

Source in your repo No account or hosted runtime Offline verification included Python · Go · Node

01 — Find your API

The live health board for every API worth integrating.

Search any API and see exactly what its connector covers, in which languages, what's verified, what's degraded — and the moment an upstream spec quietly changes shape. The popular ones and the long tail that SDKs forgot.

4,000+ APIs watched 100 ready to install Go · Python · Node more added weekly

API	Languages	Tools	Spec status
Notion no official Go SDK — now you own one	py go node	41 verified · 2 degraded	current
HubSpot one shape across all 6 hubs	py go node	128 verified · 14 degraded	spec changed 3d ago
Linear no official Go SDK	py go node	57 verified · 3 degraded	current
Twilio	py go node	88 verified · 6 degraded	current
Stripe	py go node	142 verified · 8 degraded	current
Shopify	py go node	167 verified · 19 degraded	4 tools newly degraded

a representative slice — the full board lists every watched API · green = a language with no official SDK · see the full board →

02 — Why this, not an SDK or a platform

For everywhere the official SDK isn't.

If Stripe ships a great SDK in your language — use it. verifyport is for the rest of the integration map: the wrong language, the long tail, and the agent that needs many tools at once without a hosted broker in the path.

</>

Your language, not just theirs

Most APIs ship a JavaScript SDK and little else. Need it in Go? Or Python where there's only docs? You get the same audited client in all three — idiomatic, owned, readable.

⊞

One shape for your agent

Wiring tools into an agent? Every connector speaks one consistent shape, so 40 APIs feel like one — and they run with your credentials, with no proxy holding the keys.

⦸

No middleman, ever

Not a platform you route through. Connectors live in your repo and run in your stack. Verification is offline. There's no server of ours to breach, bill you, or go down.

03 — The proof

Don't trust us. Run it.

Every connector ships with a dependency-free verifier. One command re-proves the whole thing — offline, in about a minute. No call leaves your machine.

~/project — verify

$ npx verifyport add notion --lang go
✔ added ./connectors/notion  ·  Go — an SDK Notion never shipped
✔ wrote verify.py  ·  0 dependencies added

$ python verify.py
  verifyport · offline verification

  ✔ baseline      every shipped file matches its recorded hash
  ✔ routes        the client covers every endpoint in the spec
  ✔ error shape   4xx responses parsed to one consistent type
  ✔ contract      verified tools match their declared schema
  ✔ credentials   read from env only — never written, never sent
  ⚠ degraded      2 tools have no upstream response schema (marked, not hidden)

  PASS  · verified offline · nothing left this machine

no keys · no network · no account — the verifier is plain standard-library code you can read

04 — Honest by default

We mark what others ship silently.

A connector is only as good as the spec it's built from. When an API's own spec is incomplete, we don't paper over it — we label it, in the code and on the board, and let you decide.

Verified

The output contract is proven.

Inputs and outputs are validated, identically, across Go, Python, and Node — the connector produces exactly the shape it declares. Checked, not claimed.

Degraded

The API's spec left gaps.

When an upstream spec omits its response shape, we can't prove the output — so we say so. It still ships and still works. It just never pretends to be more than it is.

What “verified” means — precisely

the connector matches the upstream spec we built it from
Python, Go, and Node expose the same tool contract
error behavior is identical across languages
every shipped file matches its recorded hash
the verifier passes offline, with 0 dependencies

What it does not claim: the API's uptime, latency, or how it behaves on a given day. We prove the connector we ship — not the service you call.

05 — Three steps

Find it. Add it. Verify it.

Find

Search any API on the Observatory and see exactly what its connector covers — and in which languages — before you touch a thing.

Add

Run verifyport add <api>. Owned source for Go, Python, or Node lands in your repo — no package dependency, no hosted runtime, nothing that phones home.

Verify

Run verify.py. Schemas, routes, error shapes and credential handling are re-proven offline, in about a minute.

Know the moment an API changes shape.

Subscribe to the connectors you use. When an upstream spec drifts or a tool degrades, you hear it from us — before it breaks in production. Taking the fix is an ordinary git merge.

drift alerts · weekly editions · no spam — just the diffs that matter

06 — Questions

The honest answers.

How is this different from an official SDK?

For a popular API in a popular language, an official SDK is great — use it. verifyport is for everywhere it isn't: APIs with no SDK in your language (Go especially), the long tail with no SDK at all, and the case where you want one uniform client shape across many APIs at once — all as code you own, not a dependency you import.

Can I use these as tools for an AI agent?

Yes — that's a primary use. Every connector exposes the same consistent shape, so wiring many APIs into an agent is uniform instead of bespoke, and each call runs with your own credentials. No hosted tool-broker sits in the path holding your keys.

Is it really free?

Yes. The connectors are MIT-licensed and the code is yours — copy it, fork it, ship it. No seat, no metered call, no upsell hiding in the install.

Do I depend on your servers?

No. A connector runs inside your application with your own credentials, and the verifier runs entirely offline. Nothing in your runtime path calls us. If verifyport vanished tomorrow, your code keeps working.

What does "degraded" mean?

The API's own published spec is missing something we'd need to fully prove the connector — usually its response shape. Rather than guess and hide it, we ship the connector and mark it degraded, on the board and in the code. Honest beats convenient.

Where do my credentials go?

Into your environment, read from variables you control — and nowhere else. We never hold, broker, or see a key. That's the whole point of owning the code.