whisper-id

A real, routable IPv6 identity, safe egress, and the full control plane for any Python agent, in two calls.

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

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

That's it. 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.

API

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

Pass the proxy explicitly instead of via env if you prefer:

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

Keyless / serverless (no CLI)

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

from whisper_id import verify, rdap
if verify(addr):                       # one HTTPS call; works in AWS Lambda, Cloudflare, etc.
    print(rdap(addr)["name"])

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

Control plane: govern your fleet (no CLI)

With your key set, provision and govern agents over pure HTTPS, no whisper binary, so this works in serverless/edge functions too:

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
print(a["address"], a["fqdn"])

policy(default="deny", allow=["api.github.com"])   # deny-by-default DNS policy
print(policy())                                    # read it back → {'default': 'deny', ...}

for it in list_agents():                            # your fleet
    print(it["label"], it["address"])

print(agent(a["address"])["dns_queries"])          # per-agent counters
logs(agent=a["address"], kind="dns", from_="-1h")  # recent activity
revoke(a["address"])                               # irreversible

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

Security graph (keyed)

The Whisper security graph (3.6B nodes, 30B relationships) is one typed namespace. It is Cypher, and Cypher needs an API key, so the whole namespace is keyed on the same transport as the control plane above (one HTTPS POST to graph.whisper.security/api/query, the key only in the X-API-Key header). This is the keyed tier; the genuinely keyless half of Whisper stays verify / rdap (no Cypher).

from whisper_id import graph

g = graph()                                  # key from WHISPER_API_KEY (or graph("whisper-..."))

g.identify("api.openai.com")                 # vendor + operator role behind a host or IP
g.assess("8.8.8.8")                          # labelled threat posture
g.origins("cloudflare.com")                  # real origin IPs behind a CDN
g.explain("paypal.com")                      # threat-feed score + why
g.typosquat("paypal.com")                    # multi-step flow (look-alike sweep), streamed
g.run_flow("typosquat", {"domain": "paypal.com"})   # any flow by its catalog slug
g.query("CALL db.schema()")                  # raw escape hatch for any read Cypher

Fourteen direct verbs run their Cypher against the graph and return a list of column-keyed dicts ([{col: val, ...}]). The fifteen multi-step flow verbs (attackSurface, typosquat, infrastructureMapping, ...) run keyed via the gallery flow runner (console.whisper.security/api/gallery/run, a Server-Sent-Events stream): they return {slug, steps, context, output, totalLatencyMs} and stream per-step progress through an optional on_event(name, data) callback. g.run_flow(slug, inputs, params) runs any flow by its catalog slug. Every method's docstring links its docs page under whisper.security/docs.

Requirements

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

curl get.whisper.online | sh

Set WHISPER_API_KEY in the environment (or run whisper login) for the CLI-backed calls (register, egress, ip) and the pure-HTTP control plane (identity, policy, logs, agent, revoke, list_agents: these take the key directly, no CLI). verify / rdap are keyless. ($WHISPER_BIN overrides the CLI path.)

Links

• Site: https://whisper.online
• CLI: https://github.com/whisper-sec/whisper-cli

MIT licensed.