JavaScript Documentation

Complete JavaScript integration guide for BinaryOptionsToolsV2

Node.js Browser Promise-based TypeScript Ready

Installation

Get started with BinaryOptionsToolsV2 in JavaScript

bash 
npm install binaryoptionstools-v2
bash 
yarn add binaryoptionstools-v2
html 
<script src="https://cdn.jsdelivr.net/npm/binaryoptionstools-v2@latest/dist/index.min.js"></script>

Quick Start

Basic usage examples for JavaScript environments

javascript 
const { PocketOption } = require('binaryoptionstools-v2');

async function main() {
    // Initialize the client
    const client = new PocketOption({
        ssid: 'your_ssid_here'
    });

    try {
        // Get account balance
        const balance = await client.getBalance();
        console.log(`Balance: $${balance}`);

        // Get candles data
        const candles = await client.getCandles('EURUSD_otc', 60, 100);
        candles.forEach(candle => {
            console.log(`Open: ${candle.open}, Close: ${candle.close}`);
        });

        // Create a raw order
        const orderResult = await client.createRawOrder({
            asset: 'EURUSD_otc',
            amount: 10.0,
            action: 'call',
            expiration: 60
        });
        console.log(`Order ID: ${orderResult.orderId}`);

        // Check win status
        const winStatus = await client.checkWin(orderResult.orderId);
        console.log(`Win status: ${winStatus}`);

    } catch (error) {
        console.error('Error:', error.message);
    }
}

main();
html 
<!DOCTYPE html>
<html>
<head>
    <title>Binary Options Trading</title>
    <script src="https://cdn.jsdelivr.net/npm/binaryoptionstools-v2@latest/dist/index.min.js"></script>
</head>
<body>
    <script>
        async function initTrading() {
            const client = new BinaryOptionsToolsV2.PocketOption({
                ssid: 'your_ssid_here'
            });

            // Get balance and display
            const balance = await client.getBalance();
            document.getElementById('balance').textContent = `$${balance}`;

            // Stream live candles
            const stream = client.streamCandles('EURUSD_otc', 60);
            stream.on('candle', (candle) => {
                console.log('New candle:', candle);
                updateChart(candle);
            });
        }

        function updateChart(candle) {
            // Update your chart visualization here
            console.log(`Price: ${candle.close}`);
        }

        // Initialize when page loads
        window.addEventListener('load', initTrading);
    </script>
    
    <div id="balance">Loading...</div>
</body>
</html>
typescript 
import { PocketOption, OrderResult, CandleData } from 'binaryoptionstools-v2';

interface TradingConfig {
    ssid: string;
    defaultAsset: string;
    defaultAmount: number;
}

class TradingBot {
    private client: PocketOption;
    private config: TradingConfig;

    constructor(config: TradingConfig) {
        this.config = config;
        this.client = new PocketOption({
            ssid: config.ssid
        });
    }

    async getAccountInfo(): Promise<{ balance: number; history: any[] }> {
        const [balance, history] = await Promise.all([
            this.client.getBalance(),
            this.client.getHistory(50)
        ]);

        return { balance, history };
    }

    async placeOrder(
        asset: string = this.config.defaultAsset,
        amount: number = this.config.defaultAmount,
        action: 'call' | 'put' = 'call',
        expiration: number = 60
    ): Promise {
        return await this.client.createRawOrder({
            asset,
            amount,
            action,
            expiration
        });
    }

    async monitorCandles(asset: string, timeframe: number): Promise {
        const stream = this.client.streamCandles(asset, timeframe);
        
        stream.on('candle', (candle: CandleData) => {
            this.analyzeCandle(candle);
        });

        stream.on('error', (error: Error) => {
            console.error('Stream error:', error);
        });
    }

    private analyzeCandle(candle: CandleData): void {
        // Implement your trading logic here
        console.log(`Analyzing candle: ${candle.close}`);
    }
}

// Usage
const config: TradingConfig = {
    ssid: 'your_ssid_here',
    defaultAsset: 'EURUSD_otc',
    defaultAmount: 10.0
};

const bot = new TradingBot(config);
bot.monitorCandles('EURUSD_otc', 60);

Core Classes & Methods

JavaScript API reference

PocketOption

Main client class for PocketOption trading operations

getBalance() Returns Promise<number>
getCandles(asset, timeframe, count) Returns Promise<CandleData[]>
createRawOrder(options) Returns Promise<OrderResult>
checkWin(orderId) Returns Promise<WinStatus>
streamCandles(asset, timeframe) Returns EventEmitter
getHistory(limit) Returns Promise<HistoryItem[]>

Types & Interfaces

TypeScript interfaces and type definitions

CandleData { open, high, low, close, volume, timestamp }
OrderResult { orderId, success, message }
OrderOptions { asset, amount, action, expiration }
WinStatus 'win' | 'lose' | 'pending'
HistoryItem Trading history entry

Advanced Features

Professional features for JavaScript developers

🌊

Real-time Streaming

EventEmitter-based streaming for live data

const stream = client.streamCandles('EURUSD_otc', 60);
stream.on('candle', (candle) => {
    console.log('New candle:', candle.close);
});
🔧

Event-Driven Architecture

Reactive programming with event emitters

client.on('order_complete', (result) => {
    console.log('Order completed:', result);
});

client.on('error', (error) => {
    console.error('Client error:', error);
});
âš¡

Promise-based API

Modern async/await support throughout

try {
    const [balance, candles] = await Promise.all([
        client.getBalance(),
        client.getCandles('EURUSD_otc', 60, 100)
    ]);
} catch (error) {
    console.error(error);
}
🎯

TypeScript Support

Full type definitions included

import { PocketOption, OrderOptions } from 'binaryoptionstools-v2';

const options: OrderOptions = {
    asset: 'EURUSD_otc',
    amount: 10,
    action: 'call',
    expiration: 60
};
🔌

WebSocket Integration

Real-time data via WebSocket connections

client.enableWebSocket({
    reconnect: true,
    timeout: 30000
});

client.subscribeToAsset('EURUSD_otc');
📱

Cross-Platform

Works in Node.js, browsers, and mobile apps

// Node.js
const { PocketOption } = require('binaryoptionstools-v2');

// Browser
import { PocketOption } from 'binaryoptionstools-v2';

// React Native
import { PocketOption } from 'binaryoptionstools-v2/native';

Error Handling

Robust error handling patterns

javascript 
const { PocketOption, BinaryOptionsError } = require('binaryoptionstools-v2');

async function safeTrading() {
    const client = new PocketOption({ ssid: 'your_ssid' });

    try {
        // Set up error handlers
        client.on('error', (error) => {
            if (error instanceof BinaryOptionsError) {
                console.error('Trading error:', error.code, error.message);
            } else {
                console.error('Unexpected error:', error);
            }
        });

        // Connection error handling
        client.on('disconnect', () => {
            console.log('Connection lost, attempting to reconnect...');
        });

        client.on('reconnect', () => {
            console.log('Reconnected successfully');
        });

        // Graceful order placement with retry
        const maxRetries = 3;
        let attempt = 0;

        while (attempt < maxRetries) {
            try {
                const order = await client.createRawOrder({
                    asset: 'EURUSD_otc',
                    amount: 10,
                    action: 'call',
                    expiration: 60
                });

                console.log('Order placed successfully:', order.orderId);
                break;

            } catch (error) {
                attempt++;
                console.warn(`Order attempt ${attempt} failed:`, error.message);
                
                if (attempt >= maxRetries) {
                    throw new Error('Max retries exceeded');
                }
                
                // Wait before retry
                await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
            }
        }

    } catch (error) {
        console.error('Fatal error:', error.message);
        process.exit(1);
    }
}

safeTrading();

Need Professional Bot Development?

Get custom JavaScript trading bots built by experts at chipa.tech

Explore Bot Services View JavaScript Examples