ib-api 10.33.4 → 972.0

data/example/account_summary

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+#
+# This script connects to IB API and subscribes to  Account Summary Updates for certain tags
+
+require 'bundler/setup'
+require 'ib-api'
+
+# Definition of what we want listed
+# possible tags
+#            NetLiquidation,
+#            TotalCashValue - Total cash including futures pnl
+#            SettledCash - For cash accounts, this is the same as
+#            TotalCashValue
+#            AccruedCash - Net accrued interest
+#            BuyingPower - The maximum amount of marginable US stocks the
+#                account can buy
+#            EquityWithLoanValue - Cash + stocks + bonds + mutual funds
+#            PreviousDayEquityWithLoanValue,
+#            GrossPositionValue - The sum of the absolute value of all stock
+#                and equity option positions
+#            RegTEquity,
+#            RegTMargin,
+#            SMA - Special Memorandum Account
+#            InitMarginReq,
+#            MaintMarginReq,
+#            AvailableFunds,
+#            ExcessLiquidity,
+#            Cushion - Excess liquidity as a percentage of net liquidation value
+#            FullInitMarginReq,
+#            FullMaintMarginReq,
+#            FullAvailableFunds,
+#            FullExcessLiquidity,
+#            LookAheadNextChange - Time when look-ahead values take effect
+#            LookAheadInitMarginReq,
+#            LookAheadMaintMarginReq,
+#            LookAheadAvailableFunds,
+#            LookAheadExcessLiquidity,
+#            HighestSeverity - A measure of how close the account is to liquidation
+#            DayTradesRemaining - The Number of Open/Close trades a user
+#                could put on before Pattern Day Trading is detected. A value of "-1"
+#                means that the user can put on unlimited day trades.
+#            Leverage - GrossPositionValue / NetLiquidation
+#            $LEDGER - Single flag to relay all cash balance tags*, only in base
+#                currency.
+#            $LEDGER:CURRENCY - Single flag to relay all cash balance tags*, only in
+#                the specified currency.
+#            $LEDGER:ALL - Single flag to relay all cash balance tags* in all
+#
+tags =  %w( NetLiquidation InitMarginReq DayTradesRemaining )
+# connect to IB TWS.
+
+
+ib = IB::Connection.new( :client_id => 1112) do | gw | #, :port => 7496 # TWS) 
+## Subcribe to forseable events before the connection is completed
+## Subscribe to TWS alerts/errors
+	gw.subscribe(:Alert, :AccountSummary){ |msg| puts msg.to_human }
+	gw.logger.level = Logger::FATAL # DEBUG  -- INFO -- WARN -- ERROR  -- FATAL
+end
+
+ Thread.new do 
+	sleep 1
+	puts "\n******** Press <Enter> to quit *********\n\n"
+ end
+# request the  AccountSummary
+  request_id = ib.send_message :RequestAccountSummary, tags: tags.join(',')
+
+STDIN.gets
+ puts "\n *** canceling Request ..."
+		ib.send_message :CancelAccountSummary, id: request_id
+sleep 1
+puts "done."	
+
+
+=begin
+Expected Output
+
+delta:~/workspace/ib-ruby/example$ ./account_summary 
+<AccountSummary: request_id 8111, account DU167349, tag DayTradesRemaining, value -1.0, currency  >
+<AccountSummary: request_id 8111, account DU167349, tag InitMarginReq, value 93402.16, currency EUR >
+<AccountSummary: request_id 8111, account DU167349, tag NetLiquidation, value 990842.34, currency EUR >
+<AccountSummary: request_id 8111, account DF167347, tag InitMarginReq, value 0.0, currency EUR >
+<AccountSummary: request_id 8111, account DF167347, tag NetLiquidation, value 0.0, currency EUR >
+<AccountSummary: request_id 8111, account DU167348, tag DayTradesRemaining, value -1.0, currency  >
+<AccountSummary: request_id 8111, account DU167348, tag InitMarginReq, value 135317.73, currency EUR >
+<AccountSummary: request_id 8111, account DU167348, tag NetLiquidation, value 949599.26, currency EUR >
+
+******** Press <Enter> to quit *********
+=end

data/example/cancel_orders

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+#
+# This script allows you to cancel either a set of open Orders by their ids,
+# or ALL Orders opened via IB API at once. The latter is useful when your
+# robot goes crazy and opens gazillions of wrong limit orders.
+#
+# Accepts the port to connect to as  first command-parameter,  T)ws or G)ateway, which is the default
+#	
+#	Numeric Parameter are interpreted as keys for specific orders to kill
+
+require 'bundler/setup'
+require 'ib-api'
+  specified_port = ARGV[0] || 'Gateway'
+	port =  case specified_port
+					when /^[gG]/ 
+						ARGV.shift  # consume the first argument
+						4002
+					when /^[Tt]/
+						ARGV.shift # consume the first argument
+						7497
+					end
+
+# First, connect to IB TWS.
+ib = IB::Connection.new client_id: 1111, port: port  do | gw |  
+
+	# Subscribe to TWS alerts/errors and order-related messages
+	gw.subscribe(:Alert, :ManagedAccounts, :OpenOrder, :OrderStatus, :OpenOrderEnd) { |msg| puts msg.to_human }
+	# Set log level
+	gw.logger.level = Logger::FATAL # DEBUG -- INFO -- WARN -- ERROR -- FATAL
+end
+
+if ARGV.empty?
+  ib.send_message :RequestGlobalCancel
+else
+	puts "ARGV:  #{ARGV}"
+  # Will only work for Orders placed under the same :client_id
+  ib.cancel_order *ARGV
+	puts '-'*55
+	puts "Remaining Orders"
+	puts '-'*55
+end
+
+puts '-'*55
+puts "Remaining Orders"
+ib.send_message :RequestAllOpenOrders
+puts '-'*55
+
+sleep 3
+
+
+## Expected output
+#12:20:25.154 Connected to server, version: 137,
+# connection time: 2018-02-27 12:20:25 +0000 local, 2018-02-27T12:20:25+00:00 remote.
+#12:20:25.156 Got message 5 (IB::Messages::Incoming::OpenOrder)
+#<OpenOrder: <Stock: WFC USD> <Order: LMT GTC buy 100.0 1.13 Submitted #1/1562725191 from 1112/DU167348 fee 0.0>>
+#12:20:25.158 Got message 3 (IB::Messages::Incoming::OrderStatus)
+#<OrderStatus: <OrderState: Submitted #1/1562725191 from 1112 filled 0.0/100.0 at 0.0/0.0 why_held >>
+#12:20:25.197 Got message 53 (IB::Messages::Incoming::OpenOrderEnd)
+#<OpenOrderEnd: >
+#12:20:25.197 Got message 15 (IB::Messages::Incoming::ManagedAccounts)
+#12:20:25.197 No subscribers for message IB::Messages::Incoming::ManagedAccounts!
+#12:20:25.197 Got message 9 (IB::Messages::Incoming::NextValidId)
+#12:20:25.197 Got next valid order id: 2.
+#12:20:25.254 Got message 5 (IB::Messages::Incoming::OpenOrder)
+#<OpenOrder: <Stock: WFC USD> <Order: LMT GTC buy 100.0 1.13 PendingCancel #1/1562725191 from 1112/DU167348 fee 0.0>>
+#12:20:25.256 Got message 3 (IB::Messages::Incoming::OrderStatus)
+#<OrderStatus: <OrderState: PendingCancel #1/1562725191 from 1112 filled 0.0/100.0 at 0.0/0.0 why_held >>
+#12:20:25.297 Got message 53 (IB::Messages::Incoming::OpenOrderEnd)
+#<OpenOrderEnd: >
+#12:20:25.342 Got message 3 (IB::Messages::Incoming::OrderStatus)
+#<OrderStatus: <OrderState: Cancelled #1/1562725191 from 1112 filled 0.0/100.0 at 0.0/0.0 why_held >>
+#12:20:25.343 Got message 4 (IB::Messages::Incoming::Alert)
+#TWS Error 202: Order Canceled - reason:
+##

data/example/fa_accounts

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+#
+# This script receives Financial Adviser and Managed Accounts info
+
+require 'bundler/setup'
+require 'ib-api'
+
+# First, connect to IB TWS.
+ib = IB::Connection.new client_id: 1114,  port: 4002 #, :port => 7496 # TWS
+
+# Subscribe to TWS alerts/errors and FA/managed account info
+ib.subscribe(:Alert, :ManagedAccounts, :ReceiveFA) { |msg| puts msg.to_human }
+
+##
+## type of Financial Advisor configuration data
+ #                    being received from TWS. Valid values include:
+ #                    1 = GROUPS, 2 = PROFILE, 3 = ACCOUNT ALIASES
+
+ib.send_message :RequestFA, fa_data_type: 3  
+ib.send_message :RequestManagedAccounts
+
+ib.wait_for :ReceiveFA
+
+
+

data/example/fundamental_data

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+#
+# This script downloads Fundamental data for specific symbols from IB
+# This only works IF you have Reuters data subscription!
+
+require 'bundler/setup'
+
+require 'ib-api'
+
+# allocate two variables
+request_id, snapshot_data  =  nil
+
+ib = IB::Connection.new port: 7496,  :client_id => 1112 do  | gw | #, :port => 7496 # TWS
+ gw.subscribe(:Alert) { |msg| puts msg.to_human }
+
+ # Fundamental Data will arrive in XML format, we need to parse it
+ gw.subscribe(:FundamentalData) { |msg| snapshot_data = msg.xml  if msg.request_id == request_id }
+end
+
+# Request Fundamental Data for IBM. Possible report types:
+#     'estimates' - Estimates
+#     'finstat'   - Financial statements
+#     'snapshot' - Summary
+request_id = ib.send_message :RequestFundamentalData,
+                :contract => IB::Stock.new( symbol: 'ibm' ),
+                :report_type => 'snapshot'
+
+# Needs some time to receive and parse XML. Standard timeout of 1 sec is just too low.
+ib.wait_for  :FundamentalData 
+
+# Now just extract and use all the fundamental data you needed
+ puts snapshot_data[:ReportSnapshot][:TextInfo][:Text]
+ 
+ pp snapshot_data[:ReportSnapshot][:Ratios]
+STDIN.gets
+
+puts "Displaying the complete transmitted data:"
+puts ""
+
+pp snapshot_data

data/example/historic_data_cli

@@ -0,0 +1,186 @@
+#!/usr/bin/env ruby
+# This script connects to IB API, and downloads historic data
+
+require 'rubygems'
+require 'time'
+require 'getopt/long'
+require 'bundler/setup'
+require 'ib-api'
+
+include Getopt
+
+opt = Getopt::Long.getopts(
+    ["--help", BOOLEAN],
+    ["--end", REQUIRED],
+    ["--port", REQUIRED],
+    ["--security", REQUIRED],
+    ["--duration", REQUIRED],
+    ["--barsize", REQUIRED],
+    ["--csv", BOOLEAN],
+    ["--dateformat", REQUIRED],
+    ["--nonregularhours", BOOLEAN],
+    ["--what", OPTIONAL]
+)
+
+if opt["help"] || opt["security"].nil? || opt["security"].empty?
+  puts <<ENDHELP
+
+This program requires a TWS or Gateway running on localhost.
+
+----------
+
+One argument is required: --security, the security specification you want, in
+"long serialized IB-Ruby" format. This is a colon-separated string of the format:
+
+   symbol:security_type:expiry:strike:right:multiplier:exchange:primary_exchange:currency:local_symbol
+
+Fields not needed for a particular security should be left blank (e.g. strike and right are only relevant for options.)
+
+For example, to query the Apple 500 Strike Call expiring in January 2013, use:
+
+  $ ./historic_data_cli --security AAPL:OPT:202101:200:CALL::SMART::USD:
+
+Consult contract.rb for allowed values, and see also the examples in the symbols/ directory
+(load them in irb and run security#serialize_ib_ruby to see the appropriate string.)
+
+----------
+
+Options:
+
+--end is is the last time we want data for. The default is now.
+  This is eval'ed by Ruby, so you can use a Ruby expression, which must return a Time object.
+
+--duration is time period before --end, in seconds. The default is 86400 sec (1 day).
+  TWS imposes limit of 86400 sec (1 day) worth of historic data per request.
+
+--what determines what the data will be comprised of. This can be
+  "trades", "midpoint", "bid", or "ask". The default is "trades".
+
+--barsize determines how long each bar will be.
+
+  Possible bar values (from the IB documentation):
+  Values less than 30 sec do not appear to work for some securities.
+
+  sec1 = 1 sec
+  sec5 = 5 sec
+  sec15 = 15 sec
+  sec30 = 30 sec
+  min1 = 1 minute
+  min2 = 2 minutes
+  min5 = 5 minutes
+  min15 = 15 minutes (default)
+  min30 = 30 minutes
+  hour1 = 1 hour
+  day1 = 1 day
+
+--nonregularhours : Normally, only data from the instrument's regular trading
+ hours is returned. If --nonregularhours is given, all data available during the time
+ span requested is returned, even for time intervals when the market was illiquid.
+
+--dateformat : 1 (default) human-readable time/date format, like "20050307 11:32:16".
+ If you set it to 2 instead, you will get UNIX epoch offsets (seconds since Jan 1, 1970).
+
+--csv : print out the historic data in CSV format, with header.
+
+--port : 4001 for Gateway (default), 7496 for TWS, or your custom port
+
+ENDHELP
+  exit
+end
+
+### Parameters
+
+# DURATION is how much historic data we want, in seconds, before END_DATE_TIME.
+DURATION = (opt["duration"] && opt["duration"].to_i) || 86400
+
+if DURATION > 86400
+  STDERR.puts("\nTWS rejects --duration longer than 86400 seconds (1 day).\n")
+  exit(1)
+end
+
+# This is the last time we want data for.
+END_DATE_TIME = (opt["end"] && eval(opt["end"]).to_ib) || Time.now.to_ib
+
+# This can be :trades, :midpoint, :bid, or :asked
+WHAT = (opt["what"] && opt["what"].to_sym) || :trades
+
+
+# Values less than 4 do not appear to actually work; they are rejected by the server.
+#
+BAR_SIZE = (opt["barsize"] && opt["barsize"].to_sym) || :min15
+
+# If REGULAR_HOURS_ONLY is set to 0, all data available during the time
+# span requested is returned, even data bars covering time
+# intervals where the market in question was illiquid. If useRTH
+# has a non-zero value, only data within the "Regular Trading
+# Hours" of the product in question is returned, even if the time
+# span requested falls partially or completely outside of them.
+
+REGULAR_HOURS_ONLY = opt["nonregularhours"] ? 0 : 1
+
+# Using a DATE_FORMAT of 1 will cause the dates in the returned
+# messages with the historic data to be in a text format, like
+# "20050307 11:32:16". If you set :format_date to 2 instead, you
+# will get an offset in seconds from the beginning of 1970, which
+# is the same format as the UNIX epoch time.
+
+DATE_FORMAT = (opt["dateformat"] && opt["dateformat"].to_i) || 1
+
+PORT = (opt["port"] && opt["port"]) || '4002'
+
+lastMessageTime = Queue.new # for communicating with the reader thread.
+
+# First, connect to IB TWS.
+ib = IB::Connection.new( :client_id => 1112, :port => PORT) do | gw|
+
+	# Subscribe to TWS alerts/errors
+	gw.subscribe(:Alert) { |msg| puts msg.to_human }
+
+
+	# Subscribe to incoming HistoricalData events. The code passed in the
+	# block will be executed when a message of the subscribed type is
+	# received, with the received message as its argument. In this case,
+	# we just print out the data.
+	#
+	# Note that we have to look the ticker id of each incoming message
+	# up in local memory to figure out what security it relates to.
+	# The incoming message packet from TWS just identifies it by ticker id.
+	#
+	gw.subscribe(:HistoricalData) do |msg|
+		if opt["csv"]
+			puts "date,time,open,high,low,close,volume,wap,has_gaps"
+			msg.results.each do |datum|
+				puts "#{datum.time},#{datum.open},#{datum.high},#{datum.low}," +
+				"#{datum.close},#{datum.volume},#{datum.wap},#{datum.has_gaps}"
+			end
+		n
+			STDERR.puts "Received #{msg.count} items:"
+			msg.results.each { |datum| puts datum.to_s }
+		end
+		lastMessageTime.push(Time.now)
+	end
+end 
+# Now we actually request historical data for the symbols we're
+# interested in.  TWS will respond with a HistoricalData message,
+# which will be received by the code above.
+ib.send_message :RequestHistoricalData,
+                :request_id => 123,
+                :contract => opt["security"],
+                :end_date_time => END_DATE_TIME,
+                :duration => DURATION, # seconds == 1 hour
+                :bar_size => BAR_SIZE, # 1 minute bars
+                :what_to_show => WHAT,
+                :use_RTH => REGULAR_HOURS_ONLY,
+		:keep_up_todate => 0,
+                :format_date => DATE_FORMAT
+
+# A complication here is that IB does not send any indication when all historic data
+# is done being delivered. So we have to guess - when there is no more new data for
+# some period, we interpret that as "end of data" and exit.
+sleep 2
+while true
+  lastTime = lastMessageTime.pop # blocks until a message is ready on the queue
+  sleep 0.1 # .. wait ..
+  exit if lastMessageTime.empty? # if still no more messages after 2 more seconds, exit.
+end
+

data/example/list_orders

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+#
+# This script retrieves list of all Orders from TWS
+
+require 'bundler/setup'
+require 'ib-api'
+
+# Connect to IB as 0 (TWS) to retrieve all Orders, including TWS-generated ones
+ib = IB::Connection.new :client_id => 0  do |gw| #   , :port => 7497 # TWS
+
+	# Subscribe to TWS alerts/errors and order-related messages
+	counter = 0
+
+	gw.subscribe(:Alert, :ManagedAccounts, :OrderStatus, :OpenOrderEnd) { |msg| puts msg.to_human }
+
+	gw.subscribe(:OpenOrder) do |msg|
+		counter += 1
+		puts "#{counter}: #{msg.to_human}"
+
+	# Get rid of logging verbosity
+	gw.logger.level =  Logger::FATAL
+	end
+end
+
+## fire request
+ib.send_message :RequestAllOpenOrders
+
+# Wait for IB to respond to our request
+ib.wait_for :OpenOrderEnd
+sleep 1 # Let printer do the job
+
+=begin
+---> expected output
+1: <OpenOrder: <Bag: GOOG SMART USD legs: 269330045|1,269562569|1,301964119|-2 > <Order: LMT GTC buy 10.0 0.06 PreSubmitted #9/561364885 from 1112/DU167349 fee 0.0>>
+<OrderStatus: <OrderState: PreSubmitted #9/561364885 from 1112 filled 0.0/10.0 at 0.0/0.0 why_held locate>>
+2:<OpenOrder: <Stock: WFC USD> <Order: LMT DAY sell 100.0 34.05 PreSubmitted #19/561364895 from 1112/DU167349 fee 0.0>>
+<OrderStatus: <OrderState: PreSubmitted #19/561364895 from 1112 filled 0.0/100.0 at 0.0/0.0 why_held child,locate>>
+3: <OpenOrder: <Stock: WFC USD> <Order: STP DAY sell 100.0 0.0 PreSubmitted /33.55#18/561364894 from 1112/DU167349 fee 0.0>>
+<OrderStatus: <OrderState: PreSubmitted #18/561364894 from 1112 filled 0.0/100.0 at 0.0/0.0 why_held child,locate,trigger>>
+4: <OpenOrder: <Bag: GOOG SMART USD legs: 269330045|1,269562569|1,301964119|-2 > <Order: LMT GTC buy 10.0 0.06 PreSubmitted #8/1562725198 from 1112/DU167349 fee 0.0>>
+<OrderStatus: <OrderState: PreSubmitted #8/1562725198 from 1112 filled 0.0/10.0 at 0.0/0.0 why_held locate>>
+5: <OpenOrder: <Stock: WFC USD> <Order: LMT GTC buy 100.0 1.72 Submitted #3/1562725193 from 1112/DU167349 fee 0.0>>
+<OrderStatus: <OrderState: Submitted #3/1562725193 from 1112 filled 0.0/100.0 at 0.0/0.0 why_held >>
+<OpenOrderEnd: >
+=end 

data/example/portfolio_csv

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+#
+# This script exports your IB portfolio in a CSV format. Usage:
+# $ example/portfolio_csv [account] > portfolio.csv
+
+require 'bundler/setup'
+require 'ib-ruby'
+
+# Only for Advisors: you need to provide account id such as U666777
+account = ARGV[0] || ''
+accounts = []
+
+# Connect to IB TWS and subscribe to events
+ib = IB::Connection.new( :client_id => 1112 , port: 4002 ) do |gw| # , :port => 7496 # TWS
+
+	# Redirect TWS alerts/errors to STDERR to keep output file clean
+	#gw.subscribe(:Alert) { |msg| STDERR.puts msg.to_human }
+
+	# Subscribe to TWS alerts/errors and account-related messages
+	# that TWS sends in response to account data request
+	gw.subscribe(:Alert) do |msg|
+			## if an account is not given. but required, (Error 321 indicates this) 
+			## fetch data from the last account detected. (The first is most probably the Advisor-Account)
+											if  msg.code == 321
+												account = accounts.last
+												gw.send_message :RequestAccountData, :subscribe => true, :account_code => account
+											else
+												puts msg.to_human
+											end
+								end
+	# Silently ignore account-related messages other than :PortfolioValue
+	gw.subscribe(:AccountUpdateTime, :AccountValue, :ManagedAccounts, :AccountDownloadEnd) {}
+	# Get rid of logging verbosity
+	gw.logger.level =  Logger::FATAL
+
+	## Just in case: put account-names into accounts-array
+	gw.subscribe(:ManagedAccounts){  |msg| accounts = msg.accounts_list.split ',' }
+end
+
+# Output CSV headers
+puts %w[Symbol
+        SecType
+        Expiry
+        Strike
+        Right
+        Currency
+        LocalSymbol
+        Position
+        MarketPrice
+        MarketValue
+        AvgCost
+        UnrealizedPNL
+        RealizedPNL
+        Account].map {|val| "\"#{val}\""}.join(",")
+
+# Output each portfolio position as a single line in CSV format
+ib.subscribe(:PortfolioValue) do |msg|
+  contract = msg.contract
+  csv = [ contract.symbol,
+          IB::CODES[:sec_type][contract.sec_type],
+          contract.expiry,
+          contract.strike == 0 ? "" : contract.strike,
+          contract.right == :none ? "" : contract.right,
+          contract.currency,
+          contract.local_symbol,
+          msg.position,
+          msg.market_price,
+          msg.market_value,
+          msg.average_cost,
+          msg.unrealized_pnl,
+          msg.realized_pnl,
+          msg.account_name
+        ].map {|val| "\"#{val}\""}.join(",")
+   puts csv
+end
+
+# Request account data, wait for its end, unsubscribe
+ib.send_message :RequestAccountData, :subscribe => true, :account_code => account
+ib.wait_for :AccountDownloadEnd, 30
+ib.send_message :RequestAccountData, :subscribe => false, :account_code => account
+sleep 0.5

data/example/scanner_data

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+#  This Script needs testing.  remove this line after sucessfully using the scanner facility
+#
+# This script setups a scan request and retreives the results.
+
+require 'rubygems'
+require 'bundler/setup'
+require 'ib-api'
+
+
+
+# Connect to IB TWS.
+ib = IB::Connection.new :client_id => 1112 , port: 7496 do | gw | #, :port => 7497 # TWS
+
+
+	# Subscribe to TWS alerts/errors
+	gw.subscribe(:Alert) { |msg| puts msg.to_human }
+
+
+	# Subscribe to ScannerData incoming events.  The code passed in the block
+	# will be executed when a message of that type is received, with the received
+	# message as its argument. In this case, we just print out the data.
+	#
+	gw.subscribe(IB::Messages::Incoming::ScannerData) do |msg|
+		puts "ID: #{msg.request_id} : #{msg.count} items:"
+		msg.results.each { |entry| puts "  #{entry}" }
+	end
+end
+id = 42
+# Now we actually request scanner data for the type of scan we are interested.
+# Some scan types can be found here:  http://www.interactivebrokers.com/php/apiUsersGuide/apiguide/tables/available_market_scanners.htm
+mess = IB::Messages::Outgoing::RequestScannerSubscription.new(
+                    :request_id => id,
+                    :number_of_rows => 20,
+                    :instrument => "STK",
+                    :location_code => 'STK.US.MAJOR',
+                    :scan_code  => 'TOP_PERC_GAIN',
+                    :above_price => 4.0,
+                    :below_price => Float::MAX,
+                    :above_volume => 5000,
+                    :market_cap_above => 100000000,
+                    :market_cap_below =>  Float::MAX,
+                    :moody_rating_above => "",
+                    :moody_rating_below => "",
+                    :sp_rating_above => "",
+                    :sp_rating_below => "",
+                    :maturity_date_above => "",
+                    :maturity_date_below => "",
+                    :coupon_rate_above => Float::MAX,
+                    :coupon_rate_below => Float::MAX,
+                    :exclude_convertible => "",
+                    :average_option_volume_above => "", # ?
+                    :scanner_setting_pairs => "Annual,true",
+                    :stock_type_filter => "Stock"
+                    )
+                    
+ib.send_message( mess )   
+
+# IB does not send any indication when all  data is done being delivered.
+# So we need to interrupt manually when our request is answered.
+puts "\n******** Press <Enter> to exit... *********\n\n"
+STDIN.gets

data/example/template

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+#
+# Your script description here...
+
+require 'bundler/setup'
+require 'ib-api'
+
+# First, connect to IB TWS and subscribe for events. 
+ib = IB::Connection.new :client_id => 1112  do | gw | #, :port => 7497 # TWS
+
+	# Subscribe to TWS alerts/errors
+	gw.subscribe(:Alert, :ManagedAccounts) { |msg| puts msg.to_human }
+	# Set log level
+	gw.logger.level = Logger::FATAL # DEBUG  -- INFO -- WARN -- ERROR  -- FATAL
+
+end
+# Put your code here
+# ...
+

data/example/tick_data

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+# This script reproduces https://github.com/ib-ruby/ib-ruby/issues/12
+
+require 'bundler/setup'
+require 'ib-api'
+
+contract = IB::Stock.new :symbol=> 'AAPL'
+
+# First, connect to IB Gateway.
+ib = IB::Connection.new :client_id => 1112 # id to identify your script
+#                       :port => 7497     # TWS connection (instead of default Gateway)
+#                        :received => false  # Do not keep all received messages in memory
+
+ib.subscribe(:Alert) { |msg| puts msg.to_human }
+ib.subscribe(:MarketDataType) { |msg| puts msg.to_human }
+ib.subscribe(:TickGeneric, :TickString, :TickPrice, :TickSize) { |msg| puts msg.inspect }
+ib.send_message :RequestMarketDataType, :market_data_type => :delayed
+ib.send_message :RequestMarketData, id: 123, contract:  contract
+
+puts "\nSubscribed to market data"
+puts "\n******** Press <Enter> to cancel... *********\n\n"
+gets
+puts "Cancelling market data subscription.."
+
+ib.send_message :CancelMarketData, id: 123
+sleep 1
+puts "Done."