Kraken WebSocket API

The Kraken WebSocket API provides event-driven, real-time access to Kraken's spot and futures markets. Version 2 (v2) is the current API, offering public feeds for market data (no authentication required) and private authenticated feeds for account events and order management. WebSocket v2 consolidates order status and fill events into a single executions channel, replacing the separate streams from v1.

General
Developer	Kraken (Payward Inc.)
Type	WebSocket API (real-time streaming)
License	Commercial API (free with Kraken account)
Documentation	docs.kraken.com
GitHub	krakenfx/api-go

Core Features

Public feeds (no auth): ticker, order book (L2), and trade streams available without a Kraken account.
Private authenticated feeds: execution events, balance updates, and order management.
Configurable order book depth: 10, 25, 100, 500, or 1,000 levels with CRC32 checksum for integrity verification.
Level 3 data: per-order orders channel (authenticated) for full depth-of-market.
Multi-symbol subscriptions: subscribe to multiple instruments in a single message.
Request/response correlation: req_id field for matching responses to requests.
Futures support: separate WebSocket endpoint for futures market data and order management.

Endpoints

Endpoint	URL
Public (spot, v2)	`wss://ws.kraken.com/v2`
Private (spot, v2)	`wss://ws-auth.kraken.com/v2`
Futures	`wss://futures.kraken.com/ws/v1`
Colocation (spot)	`colo-london.vip-ws.kraken.com`

Public Channels

Channel	Description
`ticker`	Best bid/offer, last trade price, 24h OHLCV, VWAP, and price change percentage
`book`	Aggregated order book (L2) with configurable depth and CRC32 integrity checksum
`trade`	Trade events with side, quantity, price, order type, trade ID, and RFC3339 timestamp

Snapshots are sent on subscription by default ("snapshot": true). The ticker channel supports "bbo" (best bid/offer changes) or "trades" as the event trigger.

Private Channels (Authenticated)

Channel	Description
`executions`	Order status updates and fill events (replaces v1 `openOrders` and `ownTrades`)
`balances`	Account balance changes in real time
User Trading	Add, amend, and cancel orders via WebSocket without a REST roundtrip

Authentication for private feeds:

Call GET /0/private/GetWebSocketsToken via REST using your API credentials
Use the returned token (valid 15 minutes) in the subscribe message
Include the token as: {"event": "subscribe", "subscription": {"name": "...", "token": "..."}}

Tools and Resources

WebSocket v2 Documentation: full channel specs and message format reference.
Authentication Guide: step-by-step WebSocket token generation.
Official Go SDK: covers Spot and Derivatives WebSocket connections.
Python SDK (community): async WebSocket client with built-in reconnection handling.
Kraken CLI: kraken ws commands for WebSocket streaming from the terminal.

Ecosystem and Integrations

Rate limits are shared across REST, WebSocket, and FIX for the same API key.
Colocation endpoints are available via the Beeks Group for institutions requiring sub-millisecond access.
Commercial redistribution of market data streams requires prior approval from [email protected].
The official Go SDK supports both Spot and Derivatives WebSocket under a single import.

Subscribe to public feeds immediately at wss://ws.kraken.com/v2 without any authentication. For private feeds, generate a WebSocket token first via the REST token endpoint.

Shift Handover Briefing

Shift Handover Briefing helps incoming shift teams make sense of operational information scattered across machine telemetry, maintenance notes, operator observations, and equipment manuals. It brings those sources together into a time-bounded, prioritized handover that explains what changed, why it may need attention, and where each finding came from. The prototype demonstrates this workflow with a clearly labeled synthetic hydraulic press scenario. It normalizes events, ranks them using transparent factors such as severity, repetition, deviation, and recency, and links findings to supporting source records and manual passages. Operators can review and edit the briefing before exporting it for the next shift. The system is a decision-support aid: its suggested checks require human review and follow approved procedures. It does not control equipment or authorize maintenance. Synthesis can use an optional AMD-compatible remote endpoint; the default demo uses a deterministic local fallback, so only claim AMD hardware execution if you configure and verify that endpoint.

ERRATA

Transit controllers constantly correct themselves while handling radio, maps, incidents and live service pressure. In a conventional voice workflow, each new utterance can become another instruction which creates a dangerous failure mode when a correction conflicts with what was said seconds earlier. ERRATA is built around a stricter rule: speech is a draft; operational truth is versioned. A controller can say: “Route 55 west, skip King Edward and Cumberland until 9:30.” AssemblyAI Universal-3.5 Pro Realtime transcribes the live microphone stream. ERRATA interprets the instruction as a non-mutating draft, shows the controller exactly what would change, and waits for explicit human Apply. If the controller then says: “Wait — garde Cumberland. Make it 10.” ERRATA does not create a second instruction. It repairs the same change_id, advancing the existing service change from one revision to the next while preserving a single canonical operational state. Incomplete speech is handled safely as well. A phrase such as “Wait, keep Cumberland. Make it.” produces NEEDS_CLARIFICATION: Apply remains unavailable, the revision does not advance and the canonical hash stays unchanged. Final authority is also version-bound. A stale reviewed hash is refused; only the current reviewed state can be committed. ERRATA then serializes the canonical change into GTFS-Realtime and independently decodes the resulting protobuf so the downstream operational consequence is visible and testable. AssemblyAI is load-bearing in the live product path. AI33 provides generated voice guidance to the operator, while deterministic Python logic owns parsing, validation, revisioning, evidence generation and commit authority. ERRATA is not a passenger chatbot. It is a control layer for high-consequence voice operations where fast, fallible speech must never silently become operational truth.

Meeting notetaker

ScribeAI is a real-time meeting notetaker built on AssemblyAI's streaming transcription API. It solves a problem every team knows well: meetings generate decisions and action items that get lost the moment the call ends, buried in someone's memory or a half-finished notes doc. During a live meeting, ScribeAI streams microphone audio directly to AssemblyAI's Universal-Streaming API in real time, producing a live transcript with speaker diarization so you can see who said what as it happens. Rather than waiting until the meeting ends, ScribeAI incrementally summarizes the conversation as it unfolds — the summary, key decisions, and action items update continuously, built on the new content since the last update rather than reprocessing the entire transcript from scratch each time, keeping the live experience fast even in long meetings. Action items are extracted using structured LLM outputs, so each one comes with an inferred assignee and due date where the conversation makes that clear, not just a flat bullet list. For online meetings held elsewhere — Discord, Google Meet, or similar — ScribeAI can also capture tab/system audio alongside the microphone, so it's not limited to hearing only the local speaker. Beyond live meetings, ScribeAI includes an upload flow for pre-recorded recordings: drop in an existing video or audio file, and it runs the same transcription and summarization pipeline asynchronously, producing a full transcript, summary, and action-item list once processing completes — no live call required. Every meeting is exportable as a clean, text-searchable PDF, and past meetings live in a searchable dashboard so nothing gets lost after the call ends. The UI is built with a deliberately restrained, editorial design system — minimalist layout, a single accent color, and glass-panel surfaces used only where they earn their place — because a meeting tool people use daily should feel calm, not cluttered.

BenchMate

BenchMate is a hands-free voice assistant for anyone following a lab protocol with gloved or full hands. In the lab, stopping to read the next step or write down a number means taking gloves off and losing your place. Many people end up scribbling values on a glove or a paper towel, which is where mistakes creep in. With BenchMate you just talk. It reads each step aloud, and you can say "next", "go back", "say that again" or ask what speed a spin was. When you call out a reading ("sample two, 245 nanograms per microliter"), a change from the plan or a note, BenchMate logs it and reads it back straight away so a mishearing is caught on the spot. It runs timers and announces when they finish, without talking over you. "Scratch that" or "no, 254 not 245" corrects a mistake, and the old value stays crossed out in the record. When you say "I'm done", it builds a notebook entry with tables of readings, changes, notes, a step log, an audit trail and the full transcript. The app, not the AI, holds the record: the assistant changes it only through defined actions, and the notebook is assembled directly from what you logged. Lab data stays in your browser. BenchMate is built on AssemblyAI's Voice Agent API: real-time speech recognition tuned to each protocol's vocabulary, natural turn-taking, interruption, and tool calling. It also uses AssemblyAI's LLM Gateway to turn pasted protocols into steps. It includes a two-minute practice run, so anyone can try it at their desk.

VerbalPulse: AI Defense & Interview Copilot

VerbalPulse is a real-time voice AI copilot designed to prepare candidates and researchers for high-stakes technical interviews and academic thesis viva defenses. Preparing for rigorous examinations is often intimidating and lacks objective, instantaneous feedback. VerbalPulse solves this with an end-to-end multimodal audio and intelligence pipeline. Using a low-latency WebSocket broker built with FastAPI, VerbalPulse streams live 16 kHz PCM microphone audio and transcribes technical vocabulary in real time via AssemblyAI with specialized domain term prompting. Spoken responses are evaluated dynamically against structured rubrics powered by Google Gemini. Key capabilities include: • Adaptive Question Generation: Gemini generates targeted technical inquiries and evaluation rubrics tailored to candidate resumes, research theses, and target difficulty levels. • Instant Rubric Grading: Live evaluation scoring candidate responses across technical depth, trade-off analysis, and communication clarity. • Adaptive Difficulty Scaling: Automatically tunes subsequent question complexity based on real-time performance. • Comprehensive Feedback: Pinpoints specific technical omissions and suggests concrete answer improvements. Built with FastAPI, Python WebSockets, Google Gemini, and AssemblyAI, VerbalPulse turns defense preparation into a realistic, confidence-building experience.

Fresno LUX: A Living City

Fresno LUX is a prototype for a living intelligence layer across an entire city. Fresno already contains enormous amounts of intelligence: residents know where problems exist, nonprofits know where help is needed, businesses know where opportunities exist, educators understand gaps in learning, researchers generate knowledge, and government maintains critical infrastructure and data. The problem is that much of this intelligence is fragmented across disconnected systems. Fresno LUX connects those pieces. The platform creates a shared city graph where people, organizations, resources, needs, projects, observations, experiments, and outcomes become connected nodes. Instead of simply collecting data, LUX continuously asks: What is happening? What do we know? What is missing? What can we test? What changed? A community problem can become an observable signal. That signal can become an experiment. The experiment produces evidence. Evidence changes the system's understanding. That updated understanding informs the next action. Observe → Connect → Understand → Act → Measure → Learn → Converge. The goal is to move Fresno from disconnected information toward collective intelligence—a system where knowledge can travel across boundaries and successful solutions can be discovered, tested, measured, and replicated. LUX is designed to make the invisible connections visible: the relationship between a neighborhood and its resources, between a student and educational opportunity, between a business and workforce capacity, between environmental conditions and community health, and between an idea and measurable real-world impact. This hackathon prototype demonstrates the beginning of a Living Fresno Graph: a city that can observe itself, learn from evidence, and coordinate toward better outcomes.