Tastytrade Ruby SDK (Unofficial)

gem 'tastytrade'

require 'tastytrade'

# Create a session
session = Tastytrade::Session.new(
  username: 'your_username',
  password: 'your_password',
  remember_me: true  # Optional: enables session refresh with remember token
)

# Login
session.login

# Check if authenticated
session.authenticated? # => true

# Session will automatically refresh when expired if remember_me was enabled

# Get all accounts
accounts = Tastytrade::Models::Account.get_all(session)

# Get specific account
account = Tastytrade::Models::Account.get(session, 'account_number')

# Check account status
account.closed? # => false
account.futures_approved? # => true

# Get account balance
balance = account.get_balances(session)

# Access balance information
balance.cash_balance # => BigDecimal("10000.50")
balance.net_liquidating_value # => BigDecimal("42001.00")
balance.equity_buying_power # => BigDecimal("20000.00")
balance.available_trading_funds # => BigDecimal("12000.00")
balance.day_trading_buying_power # => BigDecimal("40000.00")
balance.derivative_buying_power # => BigDecimal("20000.00")

# Check buying power usage
balance.buying_power_usage_percentage # => BigDecimal("40.00")
balance.derivative_buying_power_usage_percentage # => BigDecimal("25.00")
balance.high_buying_power_usage? # => false (checks if > 80%)

# Check if sufficient buying power for order
balance.sufficient_buying_power?(15000) # => true
balance.sufficient_buying_power?(15000, buying_power_type: :derivative) # => true

# Calculate buying power impact
balance.buying_power_impact_percentage(15000) # => BigDecimal("75.00")

# Calculate totals
balance.total_equity_value # => BigDecimal("30001.00")
balance.total_derivative_value # => BigDecimal("4500.00")
balance.total_market_value # => BigDecimal("34501.00")

# Get all positions
positions = account.get_positions(session)

# Filter positions
positions = account.get_positions(session, 
  symbol: 'AAPL',
  underlying_symbol: 'AAPL',
  include_closed: false
)

# Work with positions
positions.each do |position|
  puts position.symbol
  puts position.quantity
  puts position.unrealized_pnl
  puts position.unrealized_pnl_percentage
  
  # Check position type
  position.equity? # => true
  position.option? # => false
  position.long? # => true
  position.short? # => false
end

# Get option chain for a symbol
chain = Tastytrade::Models::OptionChain.get_chain(session, "SPY")

# Access expirations
chain.expiration_dates.each do |date|
  options = chain.options_for_expiration(date)
  puts "#{date}: #{options.size} options"
end

# Get nested option chain with more details
nested_chain = Tastytrade::Models::NestedOptionChain.get(session, "SPY")

# Access strikes for an expiration
expiration = nested_chain.expirations.first
expiration.strikes.each do |strike|
  puts "Strike #{strike.strike_price}: Call=#{strike.call}, Put=#{strike.put}"
end

# Filter options by DTE
near_term = chain.filter_by_dte(max_dte: 30)
puts "Near-term options: #{near_term.all_options.size}"

# Filter by expiration type
weeklies = chain.weekly_expirations
monthlies = chain.monthly_expirations

# Filter by moneyness (requires current price)
current_price = BigDecimal("450")
itm_options = chain.filter_by_moneyness("ITM", current_price)
atm_strike = chain.find_atm_strike(current_price)

# Get specific strikes around ATM
focused_chain = chain.filter_by_strikes(5, current_price) # 5 strikes around ATM

# Create a formatter with color support
formatter = Tastytrade::OptionChainFormatter.new(pastel: Pastel.new)

# Display option chain with colors and formatting
puts formatter.format_table(chain, 
  current_price: 450.25,
  show_greeks: false,  # Set to true to show Greeks
  format: :detailed     # :detailed, :compact, or :greeks
)

# Export to CSV for analysis
csv_data = formatter.to_csv(chain, current_price: 450.25)
File.write("option_chain.csv", csv_data)

# Export to JSON
json_data = formatter.to_json(chain, current_price: 450.25)

# Use helper methods for custom formatting
include Tastytrade::OptionHelpers

# Format option values
format_option_volume(1234)        # => "1.2K"
format_option_currency(5.50)      # => "$5.50"
format_implied_volatility(0.185)  # => "18.5%"

# Calculate moneyness
option_moneyness(445, 450, "Call") # => "ITM"
option_moneyness(455, 450, "Put")  # => "ITM"

# Analyze spreads
bid_ask_spread(5.50, 5.55)           # => 0.05
bid_ask_spread_percentage(5.50, 5.55) # => 0.91

# Create an order leg for buying stock
leg = Tastytrade::OrderLeg.new(
  action: Tastytrade::OrderAction::BUY_TO_OPEN,
  symbol: 'AAPL',
  quantity: 100
)

# Create a market order
market_order = Tastytrade::Order.new(
  type: Tastytrade::OrderType::MARKET,
  legs: leg
)

# Create a limit order
limit_order = Tastytrade::Order.new(
  type: Tastytrade::OrderType::LIMIT,
  legs: leg,
  price: 150.50  # Will be converted to BigDecimal
)

# Place the order
response = account.place_order(session, market_order)

# Dry run (simulate order without placing)
response = account.place_order(session, limit_order, dry_run: true)

# Use the OptionOrderBuilder for easier option order creation
builder = Tastytrade::OptionOrderBuilder.new(session, account)

# Single-leg options
call_option = find_option(symbol: "SPY", strike: 450, type: :call, dte: 30)
order = builder.buy_call(call_option, quantity: 1, price: 2.50)
response = account.place_order(session, order)

# Vertical spread
long_option = find_option(symbol: "SPY", strike: 445, type: :call, dte: 30)
short_option = find_option(symbol: "SPY", strike: 455, type: :call, dte: 30)
spread_order = builder.vertical_spread(long_option, short_option, 1, price: 3.00)

# Iron Butterfly (4-leg neutral strategy)
short_call = find_option(symbol: "SPY", strike: 450, type: :call, dte: 30)
long_call = find_option(symbol: "SPY", strike: 460, type: :call, dte: 30)
short_put = find_option(symbol: "SPY", strike: 450, type: :put, dte: 30)
long_put = find_option(symbol: "SPY", strike: 440, type: :put, dte: 30)

iron_butterfly = builder.iron_butterfly(
  short_call, long_call, short_put, long_put,
  quantity: 1,
  price: 3.00  # Net credit
)

# Butterfly Spread (3-leg with 1-2-1 ratio)
long_low = find_option(symbol: "SPY", strike: 440, type: :call, dte: 30)
short_middle = find_option(symbol: "SPY", strike: 450, type: :call, dte: 30)
long_high = find_option(symbol: "SPY", strike: 460, type: :call, dte: 30)

butterfly = builder.butterfly_spread(
  long_low, short_middle, long_high,
  quantity: 1,  # Middle leg automatically gets 2x quantity
  price: 1.50   # Net debit
)

# Calendar Spread (time spread)
short_option = find_option(symbol: "SPY", strike: 450, type: :call, dte: 30)
long_option = find_option(symbol: "SPY", strike: 450, type: :call, dte: 60)

calendar = builder.calendar_spread(
  short_option, long_option,
  quantity: 1,
  price: 1.00  # Net debit
)

# Diagonal Spread (different strikes AND expirations)
short_option = find_option(symbol: "SPY", strike: 450, type: :call, dte: 30)
long_option = find_option(symbol: "SPY", strike: 455, type: :call, dte: 60)

diagonal = builder.diagonal_spread(
  short_option, long_option,
  quantity: 1,
  price: 2.00  # Net debit
)

# Calculate net premium for any multi-leg order
net_premium = builder.calculate_net_premium(spread_order)
puts "Net premium: $#{net_premium}" # Positive = credit, negative = debit

# Get live orders (open orders + orders from last 24 hours)
orders = account.get_live_orders(session)

# Filter orders by status
live_orders = account.get_live_orders(session, status: "Live")
filled_orders = account.get_live_orders(session, status: "Filled")

# Filter orders by symbol
aapl_orders = account.get_live_orders(session, underlying_symbol: "AAPL")

# Filter by time range
recent_orders = account.get_live_orders(session,
  from_time: Time.now - 86400,  # Last 24 hours
  to_time: Time.now
)

# Work with order details
orders.each do |order|
  puts order.id                  # => "12345"
  puts order.status              # => "Live"
  puts order.underlying_symbol   # => "AAPL"
  puts order.order_type          # => "Limit"
  puts order.price               # => BigDecimal("150.50")
  
  # Check order capabilities
  puts order.cancellable?        # => true
  puts order.editable?           # => true
  puts order.terminal?           # => false
  puts order.working?            # => true
  
  # Check fill status
  puts order.remaining_quantity  # => 100
  puts order.filled_quantity     # => 0
  
  # Work with order legs
  order.legs.each do |leg|
    puts leg.symbol              # => "AAPL"
    puts leg.action              # => "Buy"
    puts leg.quantity            # => 100
    puts leg.remaining_quantity  # => 100
    puts leg.partially_filled?   # => false
  end
end

# Cancel an order
account.cancel_order(session, "12345")

# Replace an order with new parameters
new_order = Tastytrade::Order.new(
  type: Tastytrade::OrderType::LIMIT,
  legs: leg,
  price: 155.00  # New price
)
response = account.replace_order(session, "12345", new_order)

# Orders are automatically validated before submission
order = Tastytrade::Order.new(
  type: Tastytrade::OrderType::LIMIT,
  legs: leg,
  price: 150.00
)

# Validation happens automatically when placing orders
begin
  response = account.place_order(session, order)
rescue Tastytrade::OrderValidationError => e
  puts "Validation failed:"
  e.errors.each { |error| puts "  - #{error}" }
end

# You can also validate manually
order.validate!(session, account)  # Raises if invalid

# Or perform a dry-run validation
dry_run_response = order.dry_run(session, account)
puts dry_run_response.buying_power_effect
puts dry_run_response.warnings

# Specific validation error types
Tastytrade::OrderValidationError     # General validation failure
Tastytrade::InvalidSymbolError       # Symbol doesn't exist
Tastytrade::InsufficientBuyingPowerError  # Not enough buying power
Tastytrade::AccountRestrictedError   # Account has restrictions
Tastytrade::InvalidQuantityError     # Quantity out of range
Tastytrade::InvalidPriceError        # Price validation failure
Tastytrade::MarketClosedError        # Market is closed

# Direct use of OrderValidator for custom validation
validator = Tastytrade::OrderValidator.new(session, account, order)

# Perform full validation
validator.validate!  # Raises if invalid

# Or just dry-run validation
dry_run_response = validator.dry_run_validate!

# Check warnings and errors
puts validator.warnings  # Array of warning messages
puts validator.errors    # Array of error messages

# Skip validation when you're certain the order is valid
response = account.place_order(session, order, skip_validation: true)

# Get all transactions
transactions = account.get_transactions(session)

# Filter transactions
transactions = account.get_transactions(session,
  start_date: Date.new(2024, 1, 1),
  end_date: Date.new(2024, 12, 31),
  symbol: 'AAPL',
  transaction_types: ['Trade'],
  per_page: 100
)

# Work with transactions
transactions.each do |transaction|
  puts transaction.symbol               # => "AAPL"
  puts transaction.transaction_type     # => "Trade"
  puts transaction.transaction_sub_type # => "Buy"
  puts transaction.quantity             # => BigDecimal("100")
  puts transaction.price                # => BigDecimal("150.00")
  puts transaction.value                # => BigDecimal("-15000.00")
  puts transaction.net_value            # => BigDecimal("-15007.00")
  puts transaction.executed_at          # => Time object
  
  # Fee breakdown
  puts transaction.commission           # => BigDecimal("5.00")
  puts transaction.clearing_fees        # => BigDecimal("1.00")
  puts transaction.regulatory_fees      # => BigDecimal("0.50")
end