whisper-id

Three things for any Python agent, in one dependency-free package: query the Whisper security graph (7.48B nodes and 39.5B edges joining the physical, network, naming, ownership and threat layers; live totals at nic.whisper.online/stats, Cypher), give the agent a routable IPv6 identity with safe egress, and drive the full control plane.

pip install whisper-id            # add [socks] for requests+SOCKS: pip install "whisper-id[socks]"

The security graph (keyless, zero setup)

The Whisper graph knows who operates a host, its threat posture, its look-alikes, the real origins behind a CDN, WHOIS history, and 15 named investigations. The direct read verbs run with no key at all (rate-limited taste, ~100/window). One import, real answers:

from whisper_id import graph

g = graph()                                  # no key needed for the read verbs

g.assess("8.8.8.8")                          # -> [{'host': '8.8.8.8', 'label': 'benign-allowlisted', 'band': 'INFO', ...}]
g.identify("api.openai.com")                 # who operates this host -> vendor + operator roles
g.origins("cloudflare.com")                  # the real origin IPs behind a CDN
g.explain("paypal.com")                      # threat-feed score + why

Set WHISPER_API_KEY (or graph("whisper_live_...")) to lift the keyless rate limit. Every verb is sent either way; the graph decides what to answer:

g = graph("whisper_live_...")                # with a key: the keyless rate limit is lifted

# raw Cypher, your own query, parameters bound as $-params (never string-built):
g.query("MATCH (h:HOSTNAME {name:$n})-[:RESOLVES_TO]->(ip) RETURN ip.name AS ip LIMIT 5", {"n": "github.com"})

# a named catalog recipe (a multi-step investigation, streamed over SSE):
g.typosquat("paypal.com")                    # look-alike sweep -> registered variants + verdict
g.run_flow("attack-surface", {"domain": "github.com"})   # any flow by its catalog slug

# discover the whole catalog (29 queries + flows) with no key, no network:
for r in g.recipes():
    print(r["method"], "keyless" if r["keyless"] else "keyed", r["docs_url"])

Every verb maps to a catalog entry with its own docs page under whisper.security/docs (e.g. assess, identify); recipes() carries the exact docs_url for each. The 13 direct reads answer keyless; the 15 multi-step flows and the submit write channel are proxied up the same way and the graph decides. Full query reference: whisper-catalog.

Identity + egress

from whisper_id import register, egress
import requests

agent = register("my-bot")                       # a routable Whisper /128 identity
with egress():                                   # route this block through your /128
    requests.get("https://api64.ipify.org").text # leaves from your Whisper IPv6

Inside the with block the standard proxy env vars point at your local Whisper proxy, so requests, httpx, urllib, and most libraries just work; on exit they're restored. Pass the proxy explicitly if you prefer:

with egress(set_env=False) as e:
    requests.get(url, proxies=e.proxies)

API

Control plane: pure-HTTP (no CLI), one HTTPS call each; needs your key (arg key=... or WHISPER_API_KEY):

Keyless / serverless (no key, no CLI)

The graph read verbs plus verify, verify_details, rdap, and egress_ip are keyless: pure HTTPS, no whisper CLI, no key, so they run anywhere including serverless/edge functions:

from whisper_id import graph, verify, rdap

if verify(addr):                       # one HTTPS call; works in AWS Lambda, Cloudflare, etc.
    print(rdap(addr)["name"])
print(graph().assess(addr))            # keyless threat posture, same anywhere

register, egress, and ip need the CLI (egress needs the local proxy; register needs your key).

Control plane: govern your fleet (no CLI)

import os
from whisper_id import identity, list_agents, policy, logs, agent, revoke

os.environ["WHISPER_API_KEY"] = "whisper_live_..."   # or pass key=... to any call

a = identity("scout")                              # allocate a routable /128
policy(default="deny", allow=["api.github.com"])   # deny-by-default DNS policy
logs(agent=a["address"], kind="dns", from_="-1h")  # recent activity
revoke(a["address"])                               # irreversible

Every control call is one HTTPS POST of CALL whisper.agents({op, args}); it raises WhisperError with the server's message on failure. Set WHISPER_CONTROL_URL / WHISPER_RDAP_URL / WHISPER_FLOW_RUN_URL to point at a self-hosted deployment.

Requirements

For register / egress / ip, the whisper CLI on your PATH (this package is a thin, dependency-free wrapper over it). The graph read verbs and the keyless calls above need nothing.

curl -fsSL https://get.whisper.online | sh

Set WHISPER_API_KEY in the environment (or run whisper login) for the CLI-backed calls and the control plane (whisper.agents), which always needs it. Graph calls never require a key from this SDK: they are proxied to the graph with one or without, and the graph decides what to answer. A key lifts the keyless rate limit. verify and rdap are keyless too.

Links

• Site: https://whisper.online
• Docs: https://www.whisper.security/docs
• Query catalog: https://github.com/whisper-sec/whisper-catalog
• CLI: https://github.com/whisper-sec/whisper-cli

MIT licensed.