Python SDK

pip install rulebook-sdk

from rulebook import Rulebook

client = Rulebook(api_key="your-api-key")

export RULEBOOK_API_KEY="your-api-key"

from rulebook import Rulebook

client = Rulebook()  # reads from RULEBOOK_API_KEY

export RULEBOOK_BASE_URL="https://your-custom-endpoint/api/v1"

response = client.exchanges.list()

for ex in response.data:
    print(f"{ex.name} ({ex.display_name})")
    print(f"  Fee types: {ex.fee_types}")
    print(f"  Records: {ex.record_count}")

print(f"Total exchanges: {response.meta.record_count}")

response = client.exchanges.retrieve("nasdaq")

detail = response.data
print(f"Date range: {detail.date_range.earliest} to {detail.date_range.latest}")
print(f"Actions: {detail.actions}")
print(f"Participants: {detail.participants}")
print(f"Fee categories: {detail.fee_categories}")
print(f"Query time: {response.meta.query_time_ms}ms")

page = client.fee_schedule_results.list(
    exchange_name=["nasdaq"],
    fee_type=["option"],
    fee_participant=["market_maker"],
    latest_only=True,
    page_size=10,
)

print(f"Total results: {page.meta.record_count}")
for result in page.data:
    print(f"  {result.fee_action}: {result.fee_amount} ({result.fee_symbol_type})")

response = client.fee_schedule_results.retrieve(
    "a3d76e96-0cad-4ece-9db1-7ad3c743bdf8",
    include_footnotes=True,
    include_definitions=True,
    include_source=True,
)

result = response.data
print(f"{result.exchange_name} — {result.fee_type} — {result.fee_category}")
print(f"  Action: {result.fee_action}")
print(f"  Amount: {result.fee_amount}")
print(f"  Participant: {result.fee_participant}")
print(f"  Source: {result.source_document} (p.{result.page_number})")
print(f"Query time: {response.meta.query_time_ms}ms")

if result.relationships:
    for fn in result.relationships.footnotes:
        print(f"  Footnote: {fn.text}")
    for defn in result.relationships.definitions:
        print(f"  Definition: {defn.term} — {defn.text}")

response = client.fee_schedule_results.get_filters()

filters = response.data
print(f"Exchanges: {filters.exchange_names}")
print(f"Fee types: {filters.fee_types}")
print(f"Categories: {filters.fee_categories}")
print(f"Actions: {filters.fee_actions}")
print(f"Participants: {filters.fee_participants}")
print(f"Total records: {response.meta.record_count}")

response = client.fee_schedule_results.get_filters(
    exchange_name=["nasdaq", "nasdaq_phlx"]
)

page = client.fee_schedule_results.get_results_by_version(
    "b962c0b1-5d99-4ef6-b3f6-36cb18c08933",
    include_source=True,
    include_footnotes=True,
    page_size=50,
)

print(f"Version has {page.meta.record_count} results ({page.meta.total_pages} pages)")
for result in page.data:
    print(f"  {result.fee_action}: {result.fee_amount}")
    if result.source_document:
        print(f"    Source: {result.source_document} (p.{result.page_number})")

page_number = 0
total_fetched = 0

while True:
    page = client.fee_schedule_results.list(
        latest_only=True,
        page_size=50,
        page_number=page_number,
    )
    total_fetched += len(page.data)
    print(f"Page {page_number + 1}/{page.meta.total_pages}: {len(page.data)} results")

    if page_number >= page.meta.total_pages - 1:
        break
    page_number += 1

print(f"Fetched {total_fetched} of {page.meta.record_count} total results")

import asyncio
from rulebook import AsyncRulebook

async def main():
    async with AsyncRulebook(api_key="your-key") as client:
        exchanges = await client.exchanges.list()
        detail = await client.exchanges.retrieve("nasdaq")

        page = await client.fee_schedule_results.list(
            exchange_name=["nasdaq"],
            latest_only=True,
        )
        filters = await client.fee_schedule_results.get_filters()

asyncio.run(main())

with Rulebook(api_key="your-key") as client:
    exchanges = client.exchanges.list()
# Connection pool is cleaned up here