WebSocket

Stream Financial Data with FinFeedAPI WebSocket

Receive continuous exchange-rate updates and newly discovered SEC filings through persistent WebSocket connections.

FinFeedAPI WebSocket APIs are designed for applications that need data as it becomes available rather than repeatedly requesting updates through REST. Maintain a persistent connection and receive live financial data directly from FinFeedAPI.

Start with Free CreditsExplore Documentation

What Is a Financial Data WebSocket API?

A financial data WebSocket API maintains an open connection between your application and the data service.

Continuous updates on an open connection

Instead of sending a new HTTP request whenever fresh data is needed, the server can continuously publish updates through the existing connection.

This makes WebSocket particularly useful for applications that need to react to new information as it arrives, including live dashboards, market monitoring systems, alerts, event-driven workflows, and financial applications.

Additional WebSocket delivery can also be discussed for Enterprise deployments with custom requirements. For historical queries and data requested on demand, REST is generally the more appropriate interface.

Standard documented WebSocket access for

  • Currencies API — real-time FX and exchange-rate streaming
  • SEC API — real-time delivery of newly discovered SEC filings

Why Use FinFeedAPI WebSocket?

Polling a REST endpoint repeatedly creates unnecessary requests when an application needs continuous updates. WebSocket changes that model. After the connection is established and authenticated, data can be delivered as new information becomes available. This makes WebSocket a natural choice for event-driven systems where receiving the next update matters more than repeatedly asking whether something has changed.

What WebSocket gives you

  • Continuous streaming without repeated REST polling
  • Persistent connections for long-running applications
  • Real-time exchange-rate updates
  • Live SEC filing discovery
  • API key authentication
  • Heartbeat and connection-health mechanisms
  • Regional connectivity options for the Currencies API
  • Easy combination with REST for historical and on-demand queries

Financial Data Available Through WebSocket

Standard FinFeedAPI WebSocket support is focused on datasets where continuous delivery provides a clear advantage. Other FinFeedAPI products use different standard delivery interfaces. Organizations that require WebSocket delivery beyond the standard product offering can discuss a custom Enterprise implementation with the FinFeedAPI team.

ProductWebSocket AccessTypical Use
Currencies APIReal-time FX and exchange-rate updatesLive rates, dashboards, monitoring, financial applications
SEC APINewly discovered SEC filingsFiling alerts, monitoring, research, event-driven workflows

Stream Exchange Rates in Real Time

The Currencies WebSocket API provides continuous exchange-rate updates through a persistent connection. Instead of repeatedly requesting the latest rate through REST, applications subscribe to the assets they need and receive new data as it becomes available.

Control Your Subscription

This is useful for:

  • live FX and crypto pricing
  • financial dashboards
  • asset monitoring
  • currency conversion systems
  • market alerts
  • event-driven applications

Currencies WebSocket uses a subscribe-publish model. A client can establish or reset its subscription scope with hello, add assets using subscribe, and remove assets using unsubscribe.

Filters allow applications to select the assets or asset pairs they want to monitor instead of consuming an unrestricted stream. An optional update limit can also control the minimum delay between exchange-rate updates for the same asset pair.

Exchange-Rate Messages

Incoming exrate messages provide structured information including the base asset, quote asset, calculation type, timestamp, and exchange rate.

Clients can subscribe to asset identifiers or specific asset pairs, such as BTC/USD or EUR/USD. The stream returns exchange-rate messages matching the subscription filters, and applications can calculate additional cross rates client-side if needed.

WebSocket Endpoint

wss
wss://api-realtime.fx.finfeedapi.com
Explore Currencies WebSocket API

Regional WebSocket Endpoints and High Availability

The default Currencies WebSocket endpoint uses GeoDNS to route connections toward an appropriate datacenter. Dedicated regional endpoints are also available. This gives applications more control over connectivity and makes it possible to design regional failover strategies.

Dedicated regional endpoints

RegionEndpoint
GeoDNS (default)wss://api-realtime.fx.finfeedapi.com
North and South Americawss://api-realtime-ncsa.fx.finfeedapi.com
Europe, Middle East and Africawss://api-realtime-emea.fx.finfeedapi.com
Asia Pacificwss://api-realtime-apac.fx.finfeedapi.com

For higher availability, clients can maintain connections to more than one regional endpoint and use equivalent subscription filters across them. If one connection becomes unavailable, another regional connection can continue serving the same subscription scope. This is particularly useful for production systems where continuous access to exchange-rate updates is important.

Monitor New SEC Filings in Real Time

The SEC WebSocket API streams filings as they are discovered by FinFeedAPI. When a client establishes a connection, the server first sends a short backlog of recently discovered filings. After the backlog is delivered, the same connection continues with newly discovered filings in real time.

Historical backlog and live messages

Historical backlog and live messages can be distinguished through the is_historical field:

  • true — recently discovered backlog filing
  • false — new live filing

Live filing delivery has documented average latency of around 100 ms from discovery.

What Does the SEC Stream Include?

Each filing message provides structured metadata that applications can use immediately after a filing is discovered. This creates an event signal for applications that need to detect new regulatory information quickly. After receiving the filing event, applications can combine WebSocket with the SEC REST API to search, extract, download, or further process the filing.

Available information includes

  • SEC form type
  • filing description
  • filing date
  • SEC accepted time
  • FinFeedAPI discovery time
  • accession number
  • issuer CIK
  • historical or live status

How FinFeedAPI WebSocket Works

WebSocket keeps a connection open so new information can be delivered without creating a new HTTP request for every update. For Currencies, clients actively control the assets included in their subscription. For SEC, the connection delivers the filing stream as new filings are discovered.

Typical workflow

  1. 1Connect to the WebSocket service.
  2. 2Authenticate using your FinFeedAPI API key.
  3. 3Configure the stream or subscription where applicable.
  4. 4Keep the connection open.
  5. 5Receive new messages as data becomes available.
  6. 6Process each update inside your application.
  7. 7Monitor connection health and reconnect when required.

Keep Streaming Connections Healthy

Long-running WebSocket applications need to distinguish between a quiet data stream and a broken connection. FinFeedAPI provides connection-health mechanisms for this purpose. Applications should treat connection monitoring and reconnection logic as part of a production WebSocket implementation.

Heartbeats

Currencies WebSocket can send heartbeat messages every second during communication silence, if heartbeat was requested in the hello message.

This lets applications confirm that the connection remains active even when there are no new exchange-rate updates.

SEC WebSocket also supports optional heartbeat messages.

Ping and Pong

Clients must support WebSocket RFC6455 v13 and correctly respond to server Ping messages with Pong.

Need WebSocket for Another FinFeedAPI Product?

Standard WebSocket access is currently documented for the Currencies and SEC APIs. Enterprise customers can discuss custom WebSocket delivery for other FinFeedAPI datasets and products based on their technical and data requirements. FinFeedAPI Enterprise supports custom development and integrations, specialized delivery mechanisms, higher WebSocket limits, dedicated infrastructure, and infrastructure optimizations for demanding workloads. Availability, architecture, performance targets, and SLAs are defined according to the Enterprise implementation.

Custom implementations can be designed around

  • additional datasets or data sources
  • custom streaming delivery
  • higher throughput
  • dedicated infrastructure
  • regional architecture
  • latency requirements
  • custom message formats
  • integration-specific functionality

When Should You Use WebSocket?

WebSocket is designed for workflows where receiving new data continuously is more efficient than requesting it repeatedly.

Live Financial Dashboards

Keep displayed exchange rates updated without continuously polling REST endpoints.

FX and Asset Monitoring

Subscribe to selected assets and react as new exchange-rate information arrives.

SEC Filing Alerts

Detect newly discovered SEC filings and trigger notifications, research, or downstream processing.

Event-Driven Research

Use new filing events as signals that initiate document extraction, analysis, or other research workflows.

Automated Data Pipelines

Process new exchange-rate or filing messages as part of continuous internal data workflows.

Monitoring Systems

Maintain persistent connections for applications that need to observe financial information continuously.

Best Practices for WebSocket Integrations

WebSocket applications should be designed around long-running connections rather than individual requests. A reliable WebSocket integration should account for both incoming data and the lifecycle of the connection itself.

Keep the connection and the data aligned

  • Subscribe only to the data you need. Keep currency subscriptions aligned with the assets required by your application.
  • Enable connection monitoring. Use heartbeats and Ping/Pong behavior to detect unhealthy connections.
  • Implement reconnection logic. Production clients should be prepared to reconnect after network interruptions or server instructions.
  • Use regional endpoints when appropriate. Currencies applications can select regional connections and design multi-region failover.
  • Process messages continuously. Avoid blocking the connection while performing expensive downstream operations.
  • Combine WebSocket with REST. Use streaming to detect new information and REST when deeper or historical data is required.
  • Keep credentials secure. API keys should be handled as application secrets rather than exposed in client-side code.

WebSocket vs REST vs JSON-RPC vs MCP vs Flat Files

Choose the interface based on how your application needs to receive data. WebSocket is designed for continuous delivery. Other FinFeedAPI interfaces are better suited to targeted queries, AI workflows, or bulk historical datasets. The interfaces can also work together. WebSocket can detect new events, REST can retrieve additional information, and Flat Files can provide larger historical datasets for analysis.

InterfaceBest ForTypical Use Cases
WebSocketContinuous live streamingExchange rates, SEC filing monitoring, event-driven systems
REST APIRequest-response accessHistorical queries, snapshots, metadata, research
JSON-RPCRPC-style request-response accessApplications using RPC-based integrations
MCPAI and tool-driven workflowsAgents, copilots, automated research, data discovery
Flat Files / S3Bulk historical datasetsBacktesting, large-scale research, data warehouses
WebSocket

Stream Financial Data as It Happens

Build applications that react to new exchange-rate data and SEC filings without repeatedly polling for updates.

Need a custom streaming setup? Enterprise customers can also discuss WebSocket delivery, dedicated infrastructure, higher limits, and custom integrations tailored to their requirements.

Start with Free CreditsTalk to our Team