Rithmic API: Protocol API, R | API+ and conformance

Short answer: The Rithmic API comes in three forms: R | API+ for C++ and .NET, R | Protocol API over WebSockets and Google Protocol Buffers for any language, including Python, and R | Diamond API for co-located Linux systems. According to Rithmic's pages on 6 November 2026, you request a dev kit, build against Rithmic Test and must pass a conformance review before connecting to production; live credentials and fees come through your futures broker, since Rithmic is not one.

Facts about Rithmic come from its own pages and sign-up apps, read on 6 November 2026 from the script files they publish. No Rithmic account or dev kit was available, so nothing here connected to a Rithmic system; the Python sample ran offline. More broker APIs are in the broker API guides.

This describes documentation and recommends no broker, platform or strategy. Futures are leveraged and carry a high risk of loss, which can exceed the money you deposit, and automated orders can lose money quickly. Rules depend on your country, and account types and API access vary by broker.

Rithmic API options: R | API+, Protocol API and Diamond API

Rithmic offers three interfaces to the same R | Trade Execution Platform, and your language and hosting decide between them.

R | API+ is a set of libraries; the Protocol API is a wire-level specification that any language with WebSockets and Protocol Buffers can use. Diamond is gated: Rithmic will not discuss access until you have confirmed support with your futures commission merchant (FCM), run R | API+ in C++ on Linux in production, and recorded PnL and latency statistics.

Rithmic API request: how to get a dev kit

A Rithmic API request is a form with personal and company details, not a download, and the route depends on the interface.

• Protocol API only, new to Rithmic. The online sign-up (opens in a new tab) activates by email; its script then gives you a free Rithmic Test user ID and dev kit links.
• R | API+, or you already hold a kit. Use the contact form (opens in a new tab), API category, with first and last name, company or legal entity if any, mailing address with postal code and country, phone, email, and the versions you need (.NET, C++, Protocol).

The sign-up asks you to agree to Rithmic's documentation before activation, and the agreement texts load only inside that flow; no registration was started here, so their terms are not described. Rithmic's legal notice (opens in a new tab) says its products are licensed under a separate Software System License Agreement with restrictions on use, reverse engineering, disclosure and confidentiality.

Rithmic conformance testing and the systems you can reach

You can build against Rithmic Test without conformance, but your application must pass Rithmic's conformance review before it connects to any production system.

Rithmic says the review checks an application against its technical and behavioral requirements, that basic functionality and stability should be complete first, and that support starts the process. After you pass, your FCM or broker issues live credentials and discusses fees.

The pages conflict on testing. The API Suite and For Builders pages suggest the Exchange Simulator, the live-data paper trading system with a 14-day trial, for testing integrations, and its own page calls it the environment for R | API+ and Protocol API conformance testing, yet the API Suite page and the FAQ say the Protocol API is not available for such demos. For Protocol API work, plan on Rithmic Test and confirm with Rithmic; see also paper trading APIs.

Rithmic Python: what the Protocol API gives you

Python works through the Protocol API specification rather than an SDK: no official Python library was named on Rithmic's public pages on 6 November 2026. Rithmic does not publish the message definitions; the For Builders page says Rithmic's documentation has code examples in C++, Python and more, not seen here.

The usual Protocol Buffers workflow applies: protoc --python_out writes one _pb2.py module per .proto file; you open a WebSocket to your assigned system, send serialized messages and decode replies. The Protocol Buffers documentation (opens in a new tab) says messages do not contain descriptions of their own types, so the kit's specification, not the parser, tells you what each reply is; the next section shows a wrong guess.

The Python snippets on the API Suite and For Builders pages are illustrations, not a client: both import RequestLogin from a module named rithmic_pb2 that the pages do not supply.

Unofficial Python packages for the Protocol API exist on PyPI. They are not Rithmic's: audit them, check whether they redistribute Rithmic's files, which the license notice restricts, and note that none replaces your own dev kit, conformance review or credentials.

A tested order guard for protobuf order messages

Without the kit, this sample tests what does not depend on it: how protobuf treats bad numbers, and a guard that turns text input into well-formed order fields.

import math
from decimal import Decimal, InvalidOperation
from google.protobuf import duration_pb2, timestamp_pb2, wrappers_pb2

# What the wire does with unchecked input
for text in ("1e400", "1e-400"):
    raw = wrappers_pb2.DoubleValue(value=float(text)).SerializeToString()
    back = wrappers_pb2.DoubleValue.FromString(raw).value
    print(text, "is sent as", len(raw), "bytes and read back as", back)
stamp = timestamp_pb2.Timestamp(seconds=1_793_000_000).SerializeToString()
print("Timestamp bytes read as a Duration:", duration_pb2.Duration.FromString(stamp).seconds)

CONTRACTS = [  # hypothetical reference data
    {"symbol": "MESZ6", "exchange": "CME", "tick": Decimal("0.25"), "max_qty": 2},
    {"symbol": "MESH7", "exchange": "CME", "tick": Decimal("0.25"), "max_qty": 2},
]
used_tags = set()


def find_contract(text):
    hits = [c for c in CONTRACTS if c["symbol"] == str(text).strip()]  # exact only
    if len(hits) == 1:                      # never fall through to the last match
        return hits[0]
    raise ValueError(f"{repr(text)} matches {len(hits)} contracts")


def to_price(text, tick):
    try:
        p = Decimal(str(text))
        ok = p.is_finite() and p > 0 and p % tick == 0
    except InvalidOperation:                # bad text, None, or too large to check
        ok = False
    f = float(p) if ok else math.nan
    if not (math.isfinite(f) and f > 0):    # catches inf and underflow to 0.0
        raise ValueError(f"price {repr(text)} is not a positive multiple of {tick}")
    return f


def to_qty(text, max_qty):
    try:
        q = int(str(text))                  # 1.9 is refused, not cut
    except ValueError:
        q = 0
    if not 1 <= q <= max_qty:
        raise ValueError(f"quantity {repr(text)} is outside 1..{max_qty}")
    return q


def check_tag(tag):
    tag = tag.strip() if isinstance(tag, str) else ""
    if not tag:
        raise ValueError("empty user tag")
    if tag in used_tags:
        raise ValueError(f"duplicate user tag {repr(tag)}")
    return tag


def build_order(symbol, qty, price, tag):
    """Checked fields to copy into the kit's generated order message."""
    c = find_contract(symbol)
    order = {"symbol": c["symbol"], "exchange": c["exchange"], "tag": check_tag(tag),
             "qty": to_qty(qty, c["max_qty"]), "price": to_price(price, c["tick"])}
    used_tags.add(order["tag"])
    return order


print("accepted:", build_order("MESZ6", "1", "6000.25", "t-1"))
for args in [("MES", "1", "6000.25", "t-2"), ("MESZ6", "1", "1e400", "t-2"),
             ("MESZ6", "1", "1e-400", "t-2"), ("MESZ6", "1", "6000.1", "t-2"),
             ("MESZ6", "3", "6000.25", "t-2"), ("MESZ6", "1", "6000.25", " "),
             ("MESZ6", "1", "6000.25", "t-1")]:
    try:
        build_order(*args)
        print("accepted", args)
    except ValueError as err:
        print("refused:", err)

Output, from Python 3.11.3 and protobuf 7.34.1 on 6 November 2026, offline:

1e400 is sent as 9 bytes and read back as inf
1e-400 is sent as 0 bytes and read back as 0.0
Timestamp bytes read as a Duration: 1793000000
accepted: {'symbol': 'MESZ6', 'exchange': 'CME', 'tag': 't-1', 'qty': 1, 'price': 6000.25}
refused: 'MES' matches 0 contracts
refused: price '1e400' is not a positive multiple of 0.25
refused: price '1e-400' is not a positive multiple of 0.25
refused: price '6000.1' is not a positive multiple of 0.25
refused: quantity '3' is outside 1..2
refused: empty user tag
refused: duplicate user tag 't-1'

The first three lines are protobuf behavior, not Rithmic's: a double carries inf, a 0.0 in a field without explicit presence is not sent at all, and bytes read with the wrong class gave a valid-looking value with no error. How the kit's fields behave depends on its .proto files. The guard accepts only an exact symbol, never a partial or ambiguous one; an empty tag is an error, not a duplicate, and a refused order leaves its tag free; see client order IDs. It does not check prices against the market; see price collars in trading bot risk management. Login, subscriptions and order routing were not run: they need a kit and credentials.

Limits a Rithmic integration has to handle

Rithmic publishes operating limits, and a program that ignores them fails at predictable times.

Exchange coverage depends on your broker: the FAQ lists CME Group (CME, CBOT, NYMEX, COMEX), the Small Exchange and Nasdaq top-of-book equities, with Eurex only for customers of four named firms, while the For Builders page lists Eurex without that limit. No API request-rate, session or message-size limits were on the public pages on 6 November 2026; ask Rithmic rather than assume there are none.

What Rithmic does not publish, and the rules that apply

The public pages describe products and process, not the files you need to write a client.

• Unpublished on 6 November 2026: the message definitions and documentation, conformance criteria and timetable, API limits, prices and the sign-up agreements.
• Rithmic is not a broker. Live trading needs an account with an FCM that supports Rithmic, so that firm's terms, any prop firm's rules and your country's law apply.
• Readers in Turkey. The Capital Markets Board (SPK) said on 23 February 2023 (opens in a new tab) that residents may carry out leveraged transactions, which it describes as forex, only through firms it has authorized, that anyone else offering them commits unauthorized capital markets activity, and that it takes legal steps to block such websites (Law No. 6362 Articles 99(4) and 109(2)). Article 99(4) covers leveraged transactions offered from abroad over the internet and derivatives SPK has made subject to the same rules; Article 109(2) carries two to five years' imprisonment and a judicial fine. No text read settles whether exchange-traded futures through a foreign FCM fall under these rules, so take local legal advice.

For integration work in general, see Fincode's broker API integration page; naming Rithmic here does not mean Fincode integrates it or has built on it.

Frequently asked questions

Does Rithmic have a Python API?

No Python SDK was named on Rithmic's public pages on 6 November 2026; Python works through R | Protocol API, a WebSockets and Protocol Buffers specification you request as a dev kit.

Is the Rithmic API free?

Rithmic publishes no API price. Live credentials and any fees are arranged with your FCM or broker after conformance, and the FAQ says fees are paid in advance.

Can I use the Protocol API with the 14-day free trial?

Rithmic's FAQ says no: the Protocol API is not available for paper trading demos that include live market data, though the Exchange Simulator page says conformance testing runs there. Rithmic's steps put development on Rithmic Test.

What is Rithmic conformance testing?

A review of your application against Rithmic's technical and behavioral requirements, needed before it connects to Rithmic 01, Rithmic Paper Trading or any FCM-gated system. The criteria are not published.

Sources

• Rithmic: R | API Suite (API comparison, getting started, FAQ), read 6 November 2026 (opens in a new tab)
• Rithmic: Support FAQ (APIs, market data, maintenance windows, billing, risk management) (opens in a new tab)
• Rithmic: For Builders (API overview and code illustrations) (opens in a new tab)
• Rithmic: Exchange Simulator (paper trading, 14-day trial) (opens in a new tab)
• Rithmic: Protocol API dev kit sign-up (its configuration names the Rithmic Test system) (opens in a new tab)
• Rithmic: 14-day free trial sign-up (its configuration names the Rithmic Paper Trading system) (opens in a new tab)
• Rithmic: Contact form, API category (opens in a new tab)
• Rithmic: Legal notice (Software System License Agreement) (opens in a new tab)
• Protocol Buffers documentation: Techniques (self-describing messages) (opens in a new tab)
• Protocol Buffers documentation: Python generated code (protoc --python_out) (opens in a new tab)
• Capital Markets Law No. 6362, Articles 99 and 109 (Turkish, consolidated text) (opens in a new tab)
• SPK (Capital Markets Board): Press notice on unauthorized leveraged transactions, 23 February 2023 (Turkish) (opens in a new tab)

This guide is general information about software and markets, not investment, legal or tax advice. Automated trading can lose money, past or backtested performance does not guarantee future results, and the rules that apply depend on your jurisdiction and your exchange's terms. Sources, checks and corrections: see the editorial policy.