binaryoptionstoolsv2
Advanced tools
Python bindings for binary-options-tools. High-performance library for PocketOption trading automation with async/sync support, real-time data streaming, and WebSocket API access.
Python bindings for BinaryOptionsTools - A powerful library for automated binary options trading on PocketOption platform.
Available Features:
Install it via PyPI:
pip install binaryoptionstoolsv2
Currently supported on Windows, Linux, and macOS.
Supports Python 3.8 to 3.13.
Make sure you have rust and cargo installed (Check here)
Install maturin in order to compile the library
Once the source is downloaded (using git clone https://github.com/ChipaDevTeam/BinaryOptionsTools-v2.git) execute the following commands:
To create the .whl file
# Inside the root folder
cd BinaryOptionsToolsV2
maturin build -r
# Once the command is executed it should print a path to a .whl file, copy it and then run
pip install path/to/file.whl
To install the library in a local virtual environment
# Inside the root folder
cd BinaryOptionsToolsV2
# Activate the virtual environment if not done already
# Execute the following command and it should automatically install the library in the VM
maturin develop
Comprehensive Documentation for BinaryOptionsToolsV2
__init__.pyThis file initializes the Python module and organizes the imports for both synchronous and asynchronous functionality.
Key Details
BinaryOptionsToolsV2: Imports all elements and documentation from the Rust module.pocketoption and tracing modules for user convenience.Purpose
Serves as the entry point for the package, exposing all essential components of the library.
pocketoption folder there are 2 main filesasynchronous.pyThis file implements the PocketOptionAsync class, which provides an asynchronous interface to interact with Pocket Option.
Key Features of PocketOptionAsync
buy(): Places a buy trade asynchronously.sell(): Places a sell trade asynchronously.check_win(): Checks the outcome of a trade ('win', 'draw', or 'loss').get_candles(): Fetches historical candle data.history(): Retrieves recent data for a specific asset.compile_candles(): Compiles custom-period candlesticks from base candle data.balance(): Returns the current account balance.opened_deals(): Lists all open trades.closed_deals(): Lists all closed trades.payout(): Returns payout percentages.subscribe_symbol(): Provides an asynchronous iterator for real-time candle updates.subscribe_symbol_timed(): Provides an asynchronous iterator for timed real-time candle updates.subscribe_symbol_chunked(): Provides an asynchronous iterator for chunked real-time candle updates.server_time(): Gets the current server time.reconnect(): Manually reconnect to the server.shutdown(): Properly close the connection.Helper Class - AsyncSubscription
Facilitates asynchronous iteration over live data streams, enabling non-blocking operations.
Example Usage
from BinaryOptionsToolsV2.pocketoption import PocketOptionAsync
import asyncio
async def main():
# Initialize the client
client = PocketOptionAsync(ssid="your-session-id")
# Get account balance
balance = await client.balance()
print(f"Account Balance: ${balance}")
# Place a buy trade
trade_id, deal = await client.buy("EURUSD_otc", 1.0, 60)
print(f"Trade placed: {deal}")
# Check result
result = await client.check_win(trade_id)
print(f"Trade result: {result}")
# Subscribe to real-time data
async for candle in client.subscribe_symbol("EURUSD_otc"):
print(f"New candle: {candle}")
break # Just print one candle for demo
asyncio.run(main())
synchronous.pyThis file implements the PocketOption class, a synchronous wrapper around the asynchronous interface provided by PocketOptionAsync.
Key Features of PocketOption
buy(): Places a buy trade using synchronous execution.sell(): Places a sell trade.check_win(): Checks the trade outcome synchronously.get_candles(): Fetches historical candle data.history(): Retrieves recent data for a specific asset.compile_candles(): Compiles custom-period candlesticks from base candle data.balance(): Retrieves account balance.opened_deals(): Lists all open trades.closed_deals(): Lists all closed trades.payout(): Returns payout percentages.subscribe_symbol(): Provides a synchronous iterator for live data updates.subscribe_symbol_timed(): Provides a synchronous iterator for timed real-time candle updates.subscribe_symbol_chunked(): Provides a synchronous iterator for chunked real-time candle updates.server_time(): Gets the current server time.reconnect(): Manually reconnect to the server.shutdown(): Properly close the connection.Helper Class - SyncSubscription
Allows synchronous iteration over real-time data streams for compatibility with simpler scripts.
Example Usage
from BinaryOptionsToolsV2.pocketoption import PocketOption
import time
# Initialize the client
client = PocketOption(ssid="your-session-id")
# Get account balance
balance = client.balance()
print(f"Account Balance: ${balance}")
# Place a buy trade
trade_id, deal = client.buy("EURUSD_otc", 1.0, 60)
print(f"Trade placed: {deal}")
# Check result
result = client.check_win(trade_id)
print(f"Trade result: {result}")
# Subscribe to real-time data
stream = client.subscribe_symbol("EURUSD_otc")
for candle in stream:
print(f"New candle: {candle}")
break # Just print one candle for demo
| Feature | PocketOption (Synchronous) | PocketOptionAsync (Asynchronous) |
|---|---|---|
| Execution Type | Blocking | Non-blocking |
| Use Case | Simpler scripts | High-frequency or real-time tasks |
| Performance | Slower for concurrent tasks | Scales well with concurrent operations |
The tracing module provides functionality to initialize and manage logging for the application.
Key Functions of Tracing
path (str): Path where log files will be stored.level (str): Logging level (default is "DEBUG").terminal (bool): Whether to display logs in the terminal (default is True).Example Usage
from BinaryOptionsToolsV2.tracing import start_logs
# Initialize logging
start_logs(path="logs/", level="INFO", terminal=True)
from BinaryOptionsToolsV2.pocketoption import PocketOption
import time
def main():
# Initialize client
client = PocketOption(ssid="your-session-id")
# Get balance
balance = client.balance()
print(f"Current Balance: ${balance}")
# Place a buy trade on EURUSD for 60 seconds with $1
trade_id, deal = client.buy(asset="EURUSD_otc", amount=1.0, time=60)
print(f"Trade ID: {trade_id}")
print(f"Deal Data: {deal}")
# Wait for trade to complete (60 seconds)
time.sleep(65)
# Check the result
result = client.check_win(trade_id)
print(f"Trade Result: {result['result']}") # 'win', 'loss', or 'draw'
print(f"Profit: ${result.get('profit', 0)}")
if __name__ == "__main__":
main()
from BinaryOptionsToolsV2.pocketoption import PocketOptionAsync
import asyncio
async def main():
# Initialize client
client = PocketOptionAsync(ssid="your-session-id")
# Get balance
balance = await client.balance()
print(f"Current Balance: ${balance}")
# Place a buy trade on EURUSD for 60 seconds with $1
trade_id, deal = await client.buy(asset="EURUSD_otc", amount=1.0, time=60)
print(f"Trade ID: {trade_id}")
print(f"Deal Data: {deal}")
# Wait for trade to complete (60 seconds)
await asyncio.sleep(65)
# Check the result
result = await client.check_win(trade_id)
print(f"Trade Result: {result['result']}") # 'win', 'loss', or 'draw'
print(f"Profit: ${result.get('profit', 0)}")
if __name__ == "__main__":
asyncio.run(main())
from BinaryOptionsToolsV2.pocketoption import PocketOptionAsync
import asyncio
async def main():
client = PocketOptionAsync(ssid="your-session-id")
# Fetch historical data (60s candles, starting from now)
# Note: get_candles takes (asset, period, offset)
candles = await client.get_candles("EURUSD_otc", 60, 0)
print(f"Retrieved {len(candles)} candles")
if candles:
print("Last candle:", candles[-1])
# Output format:
# {
# 'time': 1770428373,
# 'open': 1.22354,
# 'high': 1.22355,
# 'low': 1.22354,
# 'close': 1.22355
# }
if __name__ == "__main__":
asyncio.run(main())
from BinaryOptionsToolsV2.pocketoption import PocketOptionAsync
import asyncio
async def main():
client = PocketOptionAsync(ssid="your-session-id")
# Compile 5-minute candles from 1-minute base data
# Parameters: asset, custom_period, lookback_period
candles = await client.compile_candles("EURUSD_otc", 60, 300)
print(f"Compiled {len(candles)} custom candles")
if candles:
print("Latest compiled candle:", candles[-1])
if __name__ == "__main__":
asyncio.run(main())
from BinaryOptionsToolsV2.pocketoption import PocketOption
import time
def main():
client = PocketOption(ssid="your-session-id")
# Subscribe to real-time candle data
stream = client.subscribe_symbol("EURUSD_otc")
print("Listening for real-time candles...")
for candle in stream:
print(f"Time: {candle.get('time')}")
print(f"Open: {candle.get('open')}")
print(f"High: {candle.get('high')}")
print(f"Low: {candle.get('low')}")
print(f"Close: {candle.get('close')}")
print("---")
if __name__ == "__main__":
main()
from BinaryOptionsToolsV2.pocketoption import PocketOptionAsync
import asyncio
async def main():
client = PocketOptionAsync(ssid="your-session-id")
# Subscribe to real-time candle data
async for candle in client.subscribe_symbol("EURUSD_otc"):
print(f"Time: {candle.get('time')}")
print(f"Open: {candle.get('open')}")
print(f"High: {candle.get('high')}")
print(f"Low: {candle.get('low')}")
print(f"Close: {candle.get('close')}")
print("---")
if __name__ == "__main__":
asyncio.run(main())
from BinaryOptionsToolsV2.pocketoption import PocketOption
import time
def main():
client = PocketOption(ssid="your-session-id")
# Get all opened deals
opened_deals = client.opened_deals()
if opened_deals:
print(f"You have {len(opened_deals)} opened deals:")
for deal in opened_deals:
print(f" - Trade ID: {deal.get('id')}")
print(f" Asset: {deal.get('asset')}")
print(f" Amount: ${deal.get('amount')}")
print(f" Direction: {deal.get('action')}")
else:
print("No opened deals")
if __name__ == "__main__":
main()
The client automatically establishes a connection during initialization. You can also manually manage the connection using connect(), disconnect(), and reconnect() methods.
# Asynchronous
client = PocketOptionAsync(ssid="your-session-id")
# Connection is already established here
# Manual control
await client.disconnect()
await client.connect()
# Synchronous
client_sync = PocketOption(ssid="your-session-id")
# Connection is already established here
# Manual control
client_sync.disconnect()
client_sync.connect()
ssidCommon assets include:
EURUSD_otc - Euro/US Dollar (OTC)GBPUSD_otc - British Pound/US Dollar (OTC)USDJPY_otc - US Dollar/Japanese Yen (OTC)AUDUSD_otc - Australian Dollar/US Dollar (OTC)Use _otc suffix for over-the-counter (24/7 available) assets.
Trading binary options involves substantial risk and may result in the loss of all invested capital. This library is provided for educational purposes only. Always trade responsibly and never invest more than you can afford to lose.
FAQs
Python bindings for binary-options-tools. High-performance library for PocketOption trading automation with async/sync support, real-time data streaming, and WebSocket API access.
We found that binaryoptionstoolsv2 demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
/Security News
A malicious NuGet package impersonating Sicoob exfiltrated client IDs, PFX passwords, and banking certificates through Sentry telemetry.
Security News
Feross Aboukhadijeh joins TBPN to discuss Socket's $60M Series C, 500%+ ARR growth, AI's impact on open source, and the rise in supply chain attacks.
Security News
OSV withdrew 157 OSV malware reports after automated false positives incorrectly flagged trusted npm and PyPI packages, sending bad records into tools that rely on OSV data.