DhanHQ 3.2.0 → 3.2.1

data/skills/dhanhq-ruby/examples/portfolio_summary.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "dhan_hq"
+require_relative "../scripts/dhan_helpers"
+
+# Initialize credentials
+get_client
+
+holdings = begin
+  DhanHQ::Models::Holding.all
+rescue StandardError
+  []
+end
+positions = begin
+  DhanHQ::Models::Position.all
+rescue StandardError
+  []
+end
+funds = begin
+  DhanHQ::Models::Funds.fetch
+rescue StandardError
+  nil
+end
+trades = begin
+  DhanHQ::Models::Trade.today
+rescue StandardError
+  []
+end
+
+summary = format_pnl_report(holdings, positions)
+
+puts "=" * 50
+puts "             PORTFOLIO SUMMARY"
+puts "=" * 50
+puts "\nHoldings count:   #{summary["holdings_count"]}"
+puts "Positions count:  #{summary["positions_count"]}"
+printf("Current value:    Rs. %12.2f\n", summary["current_value"])
+printf("Total P&L:        Rs. %12.2f\n", summary["total_pnl"])
+printf("Day P&L:          Rs. %12.2f\n", summary["day_pnl"])
+
+if funds
+  available = funds.availabel_balance || funds.available_balance || 0.0
+  utilized = funds.utilized_amount || 0.0
+  collateral = funds.collateral_amount || 0.0
+  withdrawable = funds.withdrawable_balance || 0.0
+
+  puts "\nFUNDS"
+  printf("  Available:      Rs. %12.2f\n", available)
+  printf("  Utilized:       Rs. %12.2f\n", utilized)
+  printf("  Collateral:     Rs. %12.2f\n", collateral)
+  printf("  Withdrawable:   Rs. %12.2f\n", withdrawable)
+end
+
+if holdings.any?
+  puts "\nTOP HOLDINGS"
+  # Sort holdings by quantity
+  sorted_holdings = holdings.sort_by { |h| -(h.total_qty || 0) }
+  sorted_holdings.first(5).each do |holding|
+    printf("  %-15s qty=%5d available=%5d\n", holding.trading_symbol, holding.total_qty.to_i, holding.available_qty.to_i)
+  end
+end
+
+open_positions = positions.reject { |p| p.net_qty.to_i.zero? }
+if open_positions.any?
+  puts "\nOPEN POSITIONS"
+  open_positions.first(5).each do |position|
+    pnl = position.realized_profit.to_f + position.unrealized_profit.to_f
+    printf("  %-20s netQty=%5d pnl=Rs. %8.0f\n", position.trading_symbol, position.net_qty.to_i, pnl)
+  end
+end
+
+puts "\nTrades today:     #{trades.size}"
+puts "=" * 50

data/skills/dhanhq-ruby/examples/super_order_with_sl.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "dhan_hq"
+require_relative "../scripts/dhan_helpers"
+
+# Initialize credentials
+get_client
+
+# Fetch LTP for Reliance
+ltp_response = DhanHQ::Models::MarketFeed.ltp("NSE_EQ" => [2885])
+if ltp_response[:status] != "success"
+  puts "Failed to fetch LTP: #{ltp_response[:remarks]}"
+  exit 1
+end
+
+reliance_ltp = ltp_response[:data][DhanHQ::Constants::ExchangeSegment::NSE_EQ]["2885"]["last_price"].to_f
+puts "Reliance LTP: Rs. #{"%.2f" % reliance_ltp}"
+
+entry_price = reliance_ltp
+target_price = (entry_price * 1.02).round(2)
+sl_price = (entry_price * 0.99).round(2)
+trailing_jump = 5.0
+
+puts "\n--- Super Order Preview ---"
+puts "Action:        BUY 1 share of RELIANCE"
+puts "Entry Price:   Rs. #{"%.2f" % entry_price}"
+puts "Target:        Rs. #{"%.2f" % target_price}"
+puts "Stop Loss:     Rs. #{"%.2f" % sl_price}"
+puts "Trailing Jump: Rs. #{"%.2f" % trailing_jump}"
+puts "Product:       INTRADAY"
+
+# Uncomment after confirmation:
+# order = DhanHQ::Models::SuperOrder.create(
+#   security_id: "2885",
+#   exchange_segment: "NSE_EQ",
+#   transaction_type: "BUY",
+#   quantity: 1,
+#   order_type: "LIMIT",
+#   product_type: "INTRADAY",
+#   price: entry_price,
+#   target_price: target_price,
+#   stop_loss_price: sl_price,
+#   trailing_jump: trailing_jump
+# )
+#
+# if order
+#   puts "Super order placed: #{order.order_id} - #{order.order_status}"
+#
+#   # Connect to Order Update websocket to listen for updates
+#   orders_client = DhanHQ::WS::Orders.connect do |update|
+#     puts "Order Update -> OrderNo: #{update.order_no}, Status: #{update.status}"
+#   end
+#
+#   sleep(10)
+#   orders_client.stop rescue nil
+# end

data/skills/dhanhq-ruby/references/backtesting-with-dhan.md

@@ -0,0 +1,65 @@
+# Backtesting With Dhan Data (Ruby SDK)
+
+## Daily Equity Backtest Skeleton
+
+```ruby
+# Fetch daily charts via HistoricalData model
+candles = DhanHQ::Models::HistoricalData.daily(
+  security_id: "2885",
+  exchange_segment: "NSE_EQ",
+  instrument: "EQUITY",
+  from_date: "2023-01-01",
+  to_date: "2024-12-31"
+)
+
+# candles is a normalized array of hashes:
+# [{ timestamp: Time, open: Float, high: Float, low: Float, close: Float, volume: Integer }]
+```
+
+Typical next steps:
+- Create signals based on technical calculations.
+- Shift positions to avoid look-ahead bias.
+- Apply transaction costs.
+- Compute CAGR, maximum drawdown, Sharpe ratio, and win rate.
+
+## Minute-Level Backtest Skeleton
+
+```ruby
+candles = DhanHQ::Models::HistoricalData.intraday(
+  security_id: "2885",
+  exchange_segment: "NSE_EQ",
+  instrument: "EQUITY",
+  from_date: "2024-09-11 09:30:00",
+  to_date: "2024-09-15 13:00:00",
+  interval: "5", # 5-minute interval
+  oi: false
+)
+```
+
+## Expired Options Backtest Skeleton
+
+```ruby
+response = DhanHQ::Models::ExpiredOptionsData.fetch(
+  underlying_scrip: 13,
+  exchange_segment: "NSE_FNO",
+  expiry_flag: "MONTH",
+  expiry_code: 1,
+  strike: "ATM",
+  option_type: "CALL",
+  required_data: ["open", "high", "low", "close", "volume", "oi", "spot"],
+  from_date: "2021-08-01",
+  to_date: "2021-08-31",
+  interval: "1"
+)
+```
+
+## Cost Model Reminders
+
+At minimum consider:
+- Brokerage charges
+- Securities Transaction Tax (STT)
+- Exchange transaction charges
+- GST (Service Tax)
+- Stamp duty
+- SEBI turnover charges
+- Slippage

data/skills/dhanhq-ruby/references/common-workflows.md

@@ -0,0 +1,76 @@
+# Common Workflows — Agent Playbooks (Ruby SDK)
+
+## Portfolio Rebalance
+
+Recommended sequence:
+1. Fetch holdings and funds.
+2. Compute target deltas.
+3. Resolve symbols and quantities.
+4. Preview proposed orders.
+5. Confirm with the user.
+6. Place live orders.
+
+```ruby
+holdings = DhanHQ::Models::Holding.all rescue []
+funds = DhanHQ::Models::Funds.fetch rescue nil
+
+if funds
+  available_cash = funds.availabel_balance || funds.available_balance || 0.0
+end
+```
+
+## Delivery Sell With eDIS
+
+Use this flow for selling demat holdings:
+1. Fetch holdings and identify ISIN.
+2. Generate TPIN: `DhanHQ::Models::Edis.generate_tpin`
+3. Generate the authorization form: `DhanHQ::Models::Edis.generate_form(isin: "...", qty: 5, exchange: "NSE", segment: "EQ")`
+4. Check status: `DhanHQ::Models::Edis.inquire(isin: "...")`
+5. Place the sell order.
+
+```ruby
+# Generate TPIN
+DhanHQ::Models::Edis.generate_tpin
+
+# Generate authorization form
+DhanHQ::Models::Edis.generate_form(isin: "INE002A01018", qty: 5, exchange: "NSE", segment: "EQ")
+
+# Check status
+status = DhanHQ::Models::Edis.inquire(isin: "INE002A01018")
+```
+
+## Single-Leg F&O Execution
+
+Recommended sequence:
+1. Resolve current contract from option chain or security master.
+2. Resolve lot size.
+3. Validate quantity.
+4. Check margin.
+5. Preview & Confirm.
+6. Place live order.
+
+```ruby
+require_relative "../scripts/dhan_helpers"
+
+chain_df, spot = fetch_chain_df(under_security_id: 13, expiry: "2025-03-27")
+atm = find_atm_row(chain_df, spot)
+
+margin = check_margin(
+  security_id: atm["ce_security_id"],
+  exchange_segment: "NSE_FNO",
+  transaction_type: "BUY",
+  quantity: 75,
+  product_type: "INTRADAY",
+  price: atm["ce_ltp"].to_f
+)
+```
+
+## Daily P&L Summary
+
+```ruby
+require_relative "../scripts/dhan_helpers"
+
+holdings = DhanHQ::Models::Holding.all
+positions = DhanHQ::Models::Position.all
+summary = format_pnl_report(holdings, positions)
+```

data/skills/dhanhq-ruby/references/error-codes.md

@@ -0,0 +1,50 @@
+# Error Codes — Complete Reference (Ruby SDK)
+
+In the Ruby SDK, raw API error codes are automatically mapped in the client layer and raised as structured exceptions.
+
+## Exception Mapping
+
+The Ruby client maps Dhan error codes to specific error classes under the `DhanHQ` module:
+
+| Error Code | Error Class | Meaning |
+|------------|-------------|---------|
+| `DH-901` | `DhanHQ::InvalidAuthenticationError` | Client ID or access token is invalid or expired |
+| `DH-902` | `DhanHQ::InvalidAccessError` | User does not have required Data API or Trading API access |
+| `DH-903` | `DhanHQ::UserAccountError` | Account setup issue or segment activation requirement |
+| `DH-904` | `DhanHQ::RateLimitError` | Rate limit exceeded |
+| `DH-905` | `DhanHQ::InputExceptionError` | Missing or invalid request fields |
+| `DH-906` | `DhanHQ::OrderError` | Order request cannot be processed |
+| `DH-907` | `DhanHQ::DataError` | Data unavailable or parameters invalid |
+| `DH-908` | `DhanHQ::InternalServerError` | Server-side failure |
+| `DH-909` | `DhanHQ::NetworkError` | Backend communication failure |
+| `DH-1111` | `DhanHQ::NoHoldingsError` | No holdings present in the account |
+| `DH-910` / other | `DhanHQ::OtherError` / `DhanHQ::Error` | Other failure reasons |
+
+## Data API Errors
+
+| Code | Exception | Meaning |
+|------|-----------|---------|
+| `800` | `DhanHQ::InternalServerError` | Internal Server Error |
+| `804` | `DhanHQ::Error` | Requested number of instruments exceeds limit |
+| `805` | `DhanHQ::RateLimitError` | Too many requests or connections |
+| `806` | `DhanHQ::DataError` | Data APIs not subscribed |
+| `807` | `DhanHQ::TokenExpiredError` | Access token is expired |
+| `808` | `DhanHQ::AuthenticationFailedError` | Authentication failed - client ID or access token invalid |
+| `809` | `DhanHQ::InvalidTokenError` | Access token is invalid |
+| `810` | `DhanHQ::InvalidClientIDError` | Client ID is invalid |
+| `811` | `DhanHQ::InvalidRequestError` | Invalid expiry date |
+| `812` | `DhanHQ::InvalidRequestError` | Invalid date format |
+| `813` | `DhanHQ::InvalidRequestError` | Invalid security ID |
+| `814` | `DhanHQ::InvalidRequestError` | Invalid request |
+
+## User Action Checklist
+
+### Invalid Data Subscription (`806` or `DH-902`)
+If you receive access errors:
+1. Log in to `web.dhan.co`.
+2. Go to **My Profile** -> **Access DhanHQ APIs**.
+3. Verify that the **Data API** plan is active.
+4. If not active, activate it, generate a fresh access token, and retry.
+
+### Static IP Error (`DH-911` or IP issue)
+If placing or managing orders fails with IP errors, ensure that the server's public IP is whitelisted in your Dhan console.

data/skills/dhanhq-ruby/references/funds.md

@@ -0,0 +1,67 @@
+# Funds & Margin — Complete Reference (Ruby SDK)
+
+The Ruby SDK exposes first-class models `DhanHQ::Models::Funds` and `DhanHQ::Models::Margin` for funds retrieval and pre-flight margin checks (both single-order and multi-leg).
+
+## Fund Limits
+
+Use `DhanHQ::Models::Funds.fetch`:
+
+```ruby
+funds = DhanHQ::Models::Funds.fetch
+
+puts "Available Balance: Rs. #{funds.availabel_balance || funds.available_balance}"
+puts "Utilized:          Rs. #{funds.utilized_amount}"
+puts "Collateral:        Rs. #{funds.collateral_amount}"
+puts "Withdrawable:      Rs. #{funds.withdrawable_balance}"
+```
+
+Normalized model attributes:
+- `dhan_client_id`
+- `availabel_balance` (or alias `available_balance`)
+- `sod_limit`
+- `collateral_amount`
+- `receiveable_amount`
+- `utilized_amount`
+- `blocked_payout_amount`
+- `withdrawable_balance`
+
+---
+
+## Margin Calculator — Single Order
+
+Use `DhanHQ::Models::Margin.calculate(params)`:
+
+```ruby
+margin = DhanHQ::Models::Margin.calculate(
+  security_id: "2885",
+  exchange_segment: "NSE_EQ",
+  transaction_type: "BUY",
+  quantity: 10,
+  product_type: "CNC",
+  price: 2450.0
+)
+
+puts "Total Margin:       Rs. #{margin.total_margin}"
+puts "Available Balance:  Rs. #{margin.available_balance}"
+puts "Brokerage Charges:  Rs. #{margin.brokerage}"
+puts "Leverage Offered:   #{margin.leverage}x"
+```
+
+---
+
+## Multi-Order Margin
+
+Unlike the Python SDK, the Ruby SDK has first-class support for multi-leg portfolio margin calculation via `DhanHQ::Models::Margin.calculate_multi(params)`:
+
+```ruby
+margin = DhanHQ::Models::Margin.calculate_multi(
+  include_position: true,
+  include_orders: true,
+  scripts: [
+    { exchange_segment: "NSE_EQ", transaction_type: "BUY", quantity: 100, product_type: "CNC", security_id: "1333", price: 1428.0 },
+    { exchange_segment: "NSE_EQ", transaction_type: "SELL", quantity: 50, product_type: "INTRADAY", security_id: "11536", price: 3000.0 }
+  ]
+)
+
+puts "Portfolio Total Margin Required: Rs. #{margin.total_margin}"
+```

data/skills/dhanhq-ruby/references/instruments.md

@@ -0,0 +1,91 @@
+# Instruments — Complete Reference (Ruby SDK)
+
+Use the security master as the primary source for `security_id`, lot size, expiry, strike, tick size, and display symbol.
+
+## Preferred SDK Entry Point
+
+In the Ruby SDK, search and load instruments segment-wise using:
+
+```ruby
+# Retrieve compact list for a single segment (returns Array of Instrument objects)
+instruments = DhanHQ::Models::Instrument.by_segment("NSE_EQ")
+```
+
+Official instrument sources (managed by the SDK internally):
+- Compact CSV: `https://images.dhan.co/api-data/api-scrip-master.csv`
+- Detailed CSV: `https://images.dhan.co/api-data/api-scrip-master-detailed.csv`
+
+---
+
+## Key Columns (Instrument Attributes)
+
+| Attribute | Meaning |
+|-----------|---------|
+| `security_id` | Security ID (String) |
+| `exchange` | Exchange ID (`NSE`, `BSE`, `MCX`) |
+| `instrument` | Instrument Type (`EQUITY`, `OPTIDX`, `OPTSTK`, etc.) |
+| `symbol_name` | Exchange trading symbol |
+| `display_name` | Dhan custom symbol |
+| `lot_size` | Lot size (Integer) |
+| `tick_size` | Tick size (Float) |
+| `expiry_date` | Expiry date (String) |
+| `strike_price` | Strike price (Float) |
+| `option_type` | Option Type (`CALL` or `PUT`) |
+
+---
+
+## Recommended Resolution Flow
+
+Use the SDK's built-in helper methods on the `Instrument` class:
+
+```ruby
+# Find specific instrument in a segment by symbol name (exact match)
+inst = DhanHQ::Models::Instrument.find("NSE_EQ", "RELIANCE")
+
+# Find by security ID instead of symbol name — use this, not `.find`, when you
+# already have a security_id (e.g. from an order, position, or option chain leg)
+inst = DhanHQ::Models::Instrument.find_by_security_id("NSE_EQ", "2885")
+
+# Search across multiple segments (finds any match)
+inst = DhanHQ::Models::Instrument.find_anywhere("RELIANCE")
+
+# Fuzzy search across multiple segments
+results = DhanHQ::Models::Instrument.search("RELIANCE")
+```
+
+`.find`'s second argument is always a **symbol name**, never a security ID — passing a security ID there silently returns `nil` (it searches symbol/underlying-symbol text, doesn't match on ID). Use `.find_by_security_id` when resolving by ID.
+
+Or leverage the helper layer in `scripts/dhan_helpers.rb`:
+
+```ruby
+require_relative "../scripts/dhan_helpers"
+
+cash = resolve_symbol("RELIANCE", "NSE_EQ")
+contract = resolve_derivative("NIFTY", strike: 24000, option_type: "CE", expiry: "2025-03-27")
+lot_size = get_lot_size(underlying: "NIFTY")
+```
+
+---
+
+## Quick-Reference Fallback IDs
+
+### Index Underlyings
+
+| Underlying | security_id | Underlying Segment |
+|------------|-------------|-------------------|
+| NIFTY 50 | `13` | `IDX_I` |
+| BANK NIFTY | `25` | `IDX_I` |
+| FINNIFTY | `27` | `IDX_I` |
+| MIDCPNIFTY | `442` | `IDX_I` |
+| SENSEX | `51` | `IDX_I` |
+
+### Common NSE Equities
+
+| Symbol | security_id |
+|--------|-------------|
+| RELIANCE | `2885` |
+| HDFCBANK | `1333` |
+| TCS | `11536` |
+| INFY | `1594` |
+| ICICIBANK | `4963` |
+| SBIN | `3045` |

data/skills/dhanhq-ruby/references/live-feed.md

@@ -0,0 +1,83 @@
+# Live Feed — Complete Reference (Ruby SDK)
+
+The Ruby SDK provides three distinct WebSocket interfaces under the `DhanHQ::WS` namespace to handle live data streaming.
+
+## 1. Market Feed (`DhanHQ::WS.connect`)
+
+Real-time market ticks, last traded prices, quotes, and market depth updates.
+
+### Usage
+
+```ruby
+# Connect to market feed. Modes: :ticker, :quote, :full
+market_client = DhanHQ::WS.connect(mode: :ticker) do |tick|
+  timestamp = tick[:ts] ? Time.at(tick[:ts]) : Time.now
+  puts "Tick: #{tick[:segment]}:#{tick[:security_id]} LTP=#{tick[:ltp]} at #{timestamp}"
+end
+
+# Subscribe to segments and security IDs
+market_client.subscribe_one(segment: "NSE_EQ", security_id: "2885")
+market_client.subscribe_one(segment: "NSE_EQ", security_id: "1333")
+
+# Stop connection
+sleep(15)
+market_client.stop
+```
+
+### Modes
+- `:ticker` - LTP (Last Traded Price) only.
+- `:quote` - OHLC + Volume updates.
+- `:full` - Full quote depth (5 levels) and Open Interest (OI) updates.
+
+---
+
+## 2. Order Updates (`DhanHQ::WS::Orders.connect`)
+
+Streams real-time updates for placed, modified, executed, or rejected orders.
+
+### Usage
+
+```ruby
+orders_client = DhanHQ::WS::Orders.connect do |update|
+  puts "Order Update: #{update.order_no} status=#{update.status}"
+  puts "  Symbol: #{update.symbol}, Traded: #{update.traded_qty}/#{update.quantity}"
+end
+
+# Register event callbacks
+orders_client.on(:update) { |order| puts "📝 Order Modified: #{order.order_no}" }
+orders_client.on(:execution) { |exec| puts "✅ Executed: #{exec[:new_traded_qty]} shares" }
+orders_client.on(:order_rejected) { |order| puts "❌ Rejected: #{order.order_no}" }
+
+sleep(15)
+orders_client.stop
+```
+
+---
+
+## 3. Market Depth (`DhanHQ::WS::MarketDepth.connect`)
+
+Streams order book depth (bid/ask levels). Supports 20-level depth.
+
+### Usage
+
+```ruby
+symbols = [
+  { symbol: "RELIANCE", exchange_segment: "NSE_EQ", security_id: "2885" },
+  { symbol: "TCS", exchange_segment: "NSE_EQ", security_id: "11536" }
+]
+
+depth_client = DhanHQ::WS::MarketDepth.connect(symbols: symbols) do |depth|
+  puts "Symbol: #{depth[:symbol]} Spread: #{depth[:spread]}"
+  puts "  Best Bid: #{depth[:best_bid]} | Best Ask: #{depth[:best_ask]}"
+end
+
+sleep(15)
+depth_client.stop
+```
+
+---
+
+## Connection Limits & Cleanup
+
+- Dhan allows up to **5 concurrent WebSocket connections** per client account.
+- Always call `client.stop` or `DhanHQ::WS.disconnect_all_local!` to prevent socket leaks and rate-limit issues (`429 Too Many Requests`).

data/skills/dhanhq-ruby/references/market-data.md

@@ -0,0 +1,119 @@
+# Market Data — Complete Reference (Ruby SDK)
+
+Timestamps returned by the `HistoricalData` model are automatically normalized into Ruby `Time` objects.
+
+## Historical Daily Data
+
+Use `DhanHQ::Models::HistoricalData.daily(params)`:
+
+```ruby
+candles = DhanHQ::Models::HistoricalData.daily(
+  security_id: "2885",
+  exchange_segment: "NSE_EQ",
+  instrument: "EQUITY",
+  from_date: "2024-01-01",
+  to_date: "2024-12-31",
+  expiry_code: 0, # Optional: 0 for current, 1 for next, 2 for far
+  oi: false       # Optional: true to include open interest
+)
+
+first_candle = candles.first
+puts "Date: #{first_candle[:timestamp]}, Close: ₹#{first_candle[:close]}"
+```
+
+Each candle in the returned array is a Hash containing:
+- `:timestamp` (Ruby `Time` object)
+- `:open` (Float)
+- `:high` (Float)
+- `:low` (Float)
+- `:close` (Float)
+- `:volume` (Integer)
+- `:open_interest` (Float, only if `oi: true` was requested)
+
+## Intraday Minute Data
+
+Use `DhanHQ::Models::HistoricalData.intraday(params)`:
+
+```ruby
+candles = DhanHQ::Models::HistoricalData.intraday(
+  security_id: "2885",
+  exchange_segment: "NSE_EQ",
+  instrument: "EQUITY",
+  interval: "15", # Supported: "1", "5", "15", "25", "60"
+  from_date: "2024-09-11 09:30:00",
+  to_date: "2024-09-15 13:00:00",
+  oi: false
+)
+```
+
+- Max 90 days of data can be polled in a single request.
+- Returns a normalized array of candle hashes.
+
+---
+
+## Market Quote Snapshots
+
+REST quote snapshots are accessed via the `DhanHQ::Models::MarketFeed` model.
+
+### Ticker Data (LTP only)
+
+```ruby
+response = DhanHQ::Models::MarketFeed.ltp(
+  "NSE_EQ" => [2885, 1333],
+  "NSE_FNO" => [49081]
+)
+
+ltp = response[:data]["NSE_EQ"]["2885"][:last_price]
+```
+
+### OHLC Data
+
+```ruby
+response = DhanHQ::Models::MarketFeed.ohlc(
+  "NSE_EQ" => [2885]
+)
+
+ohlc = response[:data]["NSE_EQ"]["2885"][:ohlc]
+```
+
+### Quote Data (Full Quote Depth & Analytics)
+
+```ruby
+response = DhanHQ::Models::MarketFeed.quote(
+  "NSE_FNO" => [49081]
+)
+
+quote = response[:data]["NSE_FNO"]["49081"]
+puts "LTP: #{quote[:last_price]}, OI: #{quote[:oi]}, Vol: #{quote[:volume]}"
+```
+
+---
+
+## Expired Options Data
+
+Use `DhanHQ::Models::ExpiredOptionsData.fetch(params)` (or direct resource access):
+
+```ruby
+response = DhanHQ::Models::ExpiredOptionsData.fetch(
+  underlying_scrip: 13,
+  exchange_segment: "NSE_FNO",
+  expiry_flag: "MONTH",
+  expiry_code: 1,
+  strike: "ATM",
+  option_type: "CALL",
+  required_data: ["open", "high", "low", "close", "volume", "oi", "spot"],
+  from_date: "2021-08-01",
+  to_date: "2021-08-31",
+  interval: "1"
+)
+```
+
+---
+
+## Timestamp Conversion
+
+If using raw API responses where timestamps are UNIX epochs, convert them to Ruby Time:
+
+```ruby
+time = Time.at(epoch_timestamp)
+```