briskapi

English | 日本語

An unofficial, pybrisk-style Python API and brisk command line for BRiSK auction data. Consume a live feed, query recordings at any point in time, pull shared recordings from a public archive, and use SBI BRiSK with your own account. This is an independent project, not affiliated with or endorsed by BRiSK, Tachibana, SBI, TSE or JPX.

Data sources:

• No account needed: the public BRiSK Next demo of 27 September 2021 (one pre-open snapshot and the first three minutes after the open), replayed at its recorded pace. This is not live market data.
• With an SBI Securities BRiSK subscription: SBI BRiSK market data (candles, margin, alerts, schedule, watchlist) and an experimental live feed.

Install

Python 3.12+. Live feeds and recording also need Node 22+, because BRiSK's own decoder is a WebAssembly module that runs under Node.

pip install 'briskapi[pandas]'      # `import briskapi` and the `brisk` command

BRiSK's decoder and demo data are downloaded at runtime; the package doesn't include them. Optional prebuilt Rust tools (brisk_quote_ingest, brisk_recording) for Linux, macOS and Windows are attached to each GitHub release. To work from source, clone the repository and run pip install -e '.[pandas]'.

Live feed

import briskapi

feed = briskapi.connect(web=True, codes=["7203", "6758"])   # returns once initial state is in
toyota = briskapi.Ticker("7203")
toyota.quote()        # current quote, updated as each frame arrives
toyota.auction()      # indicative price/volume and market-order imbalance

feed.on_quote(lambda q: print(q["code"], q["indicative_price"]), codes="6758")
for q in feed.quotes("7203"):       # one item per update; ends with the session
    if q["last_price"]:
        print("opened at", q["last_price"], q["time"])
        break

briskapi.Market().imbalances(top=10).to_pandas()
feed.wait()           # or feed.close(); `with briskapi.connect(...) as feed:` also works

Options: web=True (fetch from the demo site) or cache=DIR (a local copy of the demo assets), codes, speed (1 real time, 0 as fast as possible) and history=True (keep updates for Ticker.history()). Callbacks and iterators first receive each security's current quote, then every update in order. A slow consumer slows the feed instead of losing updates.

Recordings and the archive

recordings = briskapi.recordings(source="historical_mock")   # no AWS account needed
if recordings:
    briskapi.pull(recordings[0]["prefix"])      # verify, decode and cache; becomes the default
else:
    briskapi.record("recordings/my-session", web=True)   # record the demo if the archive is empty
# Or briskapi.load("recordings/my-session") for a local events.jsonl[.gz] or folder.

briskapi.Ticker("7203").quote(at="08:59:59.9999")             # available pre-open quote, in JST
briskapi.Ticker("7203").history(start="09:00", end="09:01")   # every update in a window
briskapi.Market().snapshot(at="09:00:00").to_pandas()

Time queries use each quote's timestamp. Toyota's first demo quote is at 08:59:59.993551 JST; an earlier query raises NotFoundError. Market().summary() returns both start and end, including for local recordings and live feeds. Archive listings skip invalid or unsupported recordings with a warning. Demo recordings may be absent; synthetic_test entries are publication probes. The legacy sample data uses the SBI wire format for protocol research and requires a wire-format decoder.

SBI BRiSK

For SBI Securities customers with a BRiSK subscription. Log in on sbi.brisk.jp in your browser, then pass its session cookies: copy them from DevTools, or use pycookiecheat's chrome_cookies("https://sbi.brisk.jp").

from briskapi import sbi

sbi.login(cookies={"session_bfaf77a2": "v2.local..."})   # remember=True saves them (owner-only file)
toyota = briskapi.Ticker("7203")
toyota.candles("5m").to_pandas()   # price bars: 5m (today), 1d, 1w or 1mo
toyota.margin(days=30)             # margin balances and stock-lending fees
market = briskapi.Market()
market.turnover()     # turnover and shares outstanding, all stocks
market.lists()        # NK225, recent IPOs, …
market.events()       # basket orders, limit up/down, volume surges
market.schedule()     # trading date, status and session times
market.watchlist()    # your saved codes

feed = sbi.connect(codes=["7203"])          # live (experimental); timing sharing follows consent
toyota.quote()                              # same calls as any feed
# To share this session's market data too, first accept the current policy:
# briskapi.consent(accept=True, contributor="your-alias", license="CC0-1.0")
# feed = sbi.connect(codes=["7203"], share_market_data=True)

Results use the conventions below. Errors are sbi.SessionExpiredError (log in again), briskapi.NotFoundError, sbi.RateLimitError and sbi.APIError. Requests are limited to one per second.

The live feed runs SBI's own decoder under Node, downloaded with your session; no browser is involved. It follows the vendor client's connect sequence: it feeds the decoder from the first frame, catches the snapshot up to the stream, forwards the decoder's pings, watches the server heartbeat and joins SBI's Socket.IO namespace when the server uses it. It hasn't yet been validated against a live SBI session, and three wire details aren't public: the Socket.IO connect parameters, the startLive payload and the catch-up request body. Set them with sbi.connect(profile={...}) and see what the server answers with trace_protocol=True (every token redacted); until they are right it stops with an explicit error rather than guessing. Please report what you see. Your cookies go only to sbi.brisk.jp. SBI market data is shared only after an explicit choice for that capture; the Python API requires share_market_data=True. With contribution on, a timing summary is shared even when market-data sharing is declined.

API reference

Prices are yen floats, with None for the vendor's zero "unavailable" value. Times are JST datetimes on the trading date. Quantities are shares; side, flag and status codes are raw vendor values. raw=True returns vendor fields (*_price10 in tenths of a yen, *_us in microseconds since JST midnight). Tabular results are lists of dicts with .to_pandas(). Errors are briskapi.BriskError and briskapi.NotFoundError. A whole-market query reads a recording once (about six seconds for the complete 420 MB demo).

Command line

brisk live --web --codes 7203,6758          # one JSON object per quote update (--raw for vendor fields)
brisk live --sbi --codes 7203               # SBI BRiSK; cookies from BRISK_SBI_COOKIES (JSON); --trace-protocol shows the handshake, wire details in BRISK_SBI_PROFILE
brisk record --web --output recordings/s1   # record a replay (shared if you agreed)
brisk list --date 20210927 --source historical_mock
brisk pull PREFIX --output recordings/downloaded   # use a prefix returned by brisk list
brisk consent [--accept | --revoke]         # show or change sharing
brisk upload recordings/s1                  # retry sharing a recording

Each command has --help. pull verifies everything before writing and never overwrites an existing folder.

At the beginning of each interactive brisk live --sbi capture with contribution enabled, you are asked whether to publish that session's market data; Enter opts in. The choice is not saved. Use --share-market-data to opt in explicitly in a script, or --no-share-market-data to decline without prompting. A clean session end is required to publish a recording. brisk list --source sbi_live lists shared SBI recordings; their market content is contributor-declared.

Sharing recordings

The first time you record or start a demo live session from the command line, the tool shows what would be shared and asks once; Enter accepts. After that, every complete demo session is uploaded and published automatically. The Python API never asks: until you decide, sessions stay on your computer.

• SBI timing sharing: percentiles of decode time, data age at receipt and frame spacing, a stall count, the frame count, the trading date, the first and last minute, and your alias and license. briskapi.Archive().timing() lists everyone's reports.
• Optional SBI market sharing: an explicit choice at the start of each capture adds the decoded securities master, prices, quantities, codes and local timing to the public archive. Cookies, tokens and connection diagnostics are excluded.
• What a demo session shares: the market data you recorded, local timing measurements (including your computer's clock, which shows when you recorded), and a public alias (random anon-… by default) and license. Your IP address is used only to rate limit uploads.
• Visibility: published recordings are public and permanent, and you cannot delete them yourself. See PRIVACY.md.
• Opting out: brisk consent --revoke, BRISK_CONTRIBUTE=0, or --no-upload for one run.
• License: accepting declares that you may redistribute the recordings under the chosen data license (CC0-1.0 or CC-BY-4.0). This project's open-source license gives no rights to vendor or exchange data. If you can't make that declaration, turn sharing off.
• Partial replays (--limit-frames) and sessions closed early are never shared.

More documentation

• ARCHITECTURE.md: how it works, data format, archive integrity and limits
• PRIVACY.md: privacy policy
• CONTRIBUTING.md: development, tests and releases
• tools/brisk_mock/README.md: Rust collector, field definitions, timing and latency
• infra/README.md: deploying your own archive
• THIRD_PARTY.md: decoder, data and pybrisk attribution

Software is MIT licensed.