Flux de travail complets

1// Request headers for REST API calls
2// PAT authentication requires Deriv-App-ID; OAuth 2.0 does not require Deriv-App-ID
3headers: {
4  'Authorization': 'Bearer YOUR_AUTHORIZATION_TOKEN',  // Authorization token (PAT or JWT)
5  'Deriv-App-ID': 'YOUR_APP_ID',                      // Required for PAT authentication
6  'Content-Type': 'application/json'
7}

1// Get authenticated WebSocket URL via OTP endpoint
2// Note: This REST call requires your authorization token
3const otpResponse = await fetch(
4  `https://api.derivws.com/trading/v1/options/accounts/${accountId}/otp`,
5  {
6    method: 'POST',
7    headers: {
8      'Authorization': 'Bearer YOUR_AUTHORIZATION_TOKEN',  // PAT or JWT token
9      'Deriv-App-ID': 'YOUR_APP_ID'                        // Required for PAT authentication
10    }
11  }
12);
13
14const otpResult = await otpResponse.json();
15const wsUrl = otpResult.data.url;
16console.log('Authenticated WebSocket URL:', wsUrl);
17// Output: wss://api.derivws.com/trading/v1/options/ws/demo?otp=abc123xyz789

1// Connect to Options WebSocket using the authenticated URL from OTP response
2// The URL already contains the correct endpoint (demo/real) and authentication
3const ws = new WebSocket(wsUrl);
4
5ws.onopen = () => {
6  console.log('Connected to Options trading WebSocket');
7  // Connection is now authenticated and ready for trading
8};
9
10ws.onmessage = (msg) => {
11  const data = JSON.parse(msg.data);
12  console.log('Received:', data);
13};
14
15ws.onerror = (error) => {
16  console.error('WebSocket error:', error);
17};
18
19ws.onclose = () => {
20  console.log('WebSocket connection closed');
21};

1// Once connected, you can send trading commands through WebSocket
2// Example: Get account balance
3ws.send(JSON.stringify({
4  balance: 1,
5  subscribe: 1,
6  req_id: 1
7}));
8
9// Example: Subscribe to tick stream
10ws.send(JSON.stringify({
11  ticks: "1HZ100V",
12  subscribe: 1,
13  req_id: 2
14}));
15
16// Example: Get price proposal
17ws.send(JSON.stringify({
18  proposal: 1,
19  amount: 10,
20  basis: "stake",
21  contract_type: "MULTDOWN",
22  currency: "USD",
23  duration_unit: "s",
24  multiplier: 10,
25  underlying_symbol: "1HZ100V",
26  subscribe: 1,
27  req_id: 3
28}));

1async function setupOptionsTrading() {
2  const AUTH_TOKEN = 'YOUR_AUTHORIZATION_TOKEN';  // PAT or JWT token
3  const APP_ID = 'YOUR_APP_ID';                   // App ID from registered application
4  const API_BASE = 'https://api.derivws.com';
5  const accountId = 'YOUR_ACCOUNT_ID';            // Your demo or real account ID
6
7  try {
8    // Step 1: Get authenticated WebSocket URL (REST, requires authorization token)
9    const otpResponse = await fetch(
10      `${API_BASE}/trading/v1/options/accounts/${accountId}/otp`,
11      {
12        method: 'POST',
13        headers: {
14          'Authorization': `Bearer ${AUTH_TOKEN}`,
15          'Deriv-App-ID': APP_ID                   // Required for PAT authentication
16        }
17      }
18    );
19
20    if (!otpResponse.ok) throw new Error(`HTTP error! status: ${otpResponse.status}`);
21    const otpData = await otpResponse.json();
22    const wsUrl = otpData.data.url;
23    console.log('✓ Authenticated WebSocket URL obtained');
24
25    // Step 2: Connect to WebSocket using the authenticated URL
26    const ws = new WebSocket(wsUrl);
27
28    ws.onopen = () => {
29      console.log('✓ WebSocket connected');
30
31      // Step 3: Start trading
32      // Subscribe to balance updates
33      ws.send(JSON.stringify({
34        balance: 1,
35        subscribe: 1,
36        req_id: 1
37      }));
38
39      // Subscribe to ticks
40      ws.send(JSON.stringify({
41        ticks: "1HZ100V",
42        subscribe: 1,
43        req_id: 2
44      }));
45    };
46
47    ws.onmessage = (msg) => {
48      const data = JSON.parse(msg.data);
49
50      if (data.msg_type === 'balance') {
51        console.log('Balance:', data.balance.balance, data.balance.currency);
52      }
53
54      if (data.msg_type === 'tick') {
55        console.log('Tick:', data.tick.quote);
56      }
57    };
58
59    return ws;
60
61  } catch (error) {
62    console.error('Setup failed:', error);
63    throw error;
64  }
65}
66
67// Run the setup
68setupOptionsTrading().then(ws => {
69  console.log('Trading setup complete. WebSocket ready for operations.');
70}).catch(err => {
71  console.error('Failed to setup trading:', err);
72});

1// PAT-Based Authentication: REST API
2const AUTH_TOKEN = 'YOUR_AUTHORIZATION_TOKEN';  // Your PAT token
3const APP_ID = 'YOUR_APP_ID';
4
5// All REST calls use the authorization token as a Bearer token
6const response = await fetch('https://api.derivws.com/trading/v1/options/accounts', {
7  method: 'POST',
8  headers: {
9    'Authorization': `Bearer ${AUTH_TOKEN}`,    // Authorization token (PAT)
10    'Deriv-App-ID': APP_ID,                      // App ID from registered application
11    'Content-Type': 'application/json'
12  },
13  body: JSON.stringify({
14    currency: 'USD',
15    group: 'row',
16    account_type: 'demo'
17  })
18});
19
20const result = await response.json();
21console.log('Authenticated REST call successful:', result);

1// OAuth 2.0 Authentication Flow (Authorization Code with PKCE)
2const CLIENT_ID = 'YOUR_CLIENT_ID';
3const REDIRECT_URI = 'https://your-app.com/callback';
4
5// --- PKCE Helper Functions ---
6function generateCodeVerifier() {
7  const array = new Uint8Array(32);
8  crypto.getRandomValues(array);
9  return btoa(String.fromCharCode(...array))
10    .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
11}
12
13async function generateCodeChallenge(verifier) {
14  const encoder = new TextEncoder();
15  const data = encoder.encode(verifier);
16  const digest = await crypto.subtle.digest('SHA-256', data);
17  return btoa(String.fromCharCode(...new Uint8Array(digest)))
18    .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
19}
20
21// Step 1: Generate PKCE values and redirect user to authorization endpoint
22const codeVerifier = generateCodeVerifier();
23const codeChallenge = await generateCodeChallenge(codeVerifier);
24const state = crypto.randomUUID();
25
26sessionStorage.setItem('code_verifier', codeVerifier);
27sessionStorage.setItem('oauth_state', state);
28
29const authUrl = new URL('https://auth.deriv.com/oauth2/auth');
30authUrl.searchParams.set('response_type', 'code');
31authUrl.searchParams.set('client_id', CLIENT_ID);
32authUrl.searchParams.set('redirect_uri', REDIRECT_URI);
33authUrl.searchParams.set('scope', 'trade account_manage');
34authUrl.searchParams.set('state', state);
35authUrl.searchParams.set('code_challenge', codeChallenge);
36authUrl.searchParams.set('code_challenge_method', 'S256');
37
38window.location.href = authUrl.toString();
39
40// Step 3: Handle the callback
41const urlParams = new URLSearchParams(window.location.search);
42const authorizationCode = urlParams.get('code');
43const returnedState = urlParams.get('state');
44
45const savedState = sessionStorage.getItem('oauth_state');
46if (returnedState !== savedState) {
47  throw new Error('State mismatch: possible CSRF attack');
48}
49
50// Step 4: Exchange the authorization code for tokens
51const savedVerifier = sessionStorage.getItem('code_verifier');
52const tokenResponse = await fetch('https://auth.deriv.com/oauth2/token', {
53  method: 'POST',
54  headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
55  body: new URLSearchParams({
56    grant_type: 'authorization_code',
57    client_id: CLIENT_ID,
58    code: authorizationCode,
59    redirect_uri: REDIRECT_URI,
60    code_verifier: savedVerifier
61  })
62});
63
64const tokenData = await tokenResponse.json();
65const accessToken = tokenData.access_token;
66console.log('Access token obtained, expires in', tokenData.expires_in, 'seconds');
67// No refresh token is returned: when the token expires or a call returns 401, run this flow again from step 1.
68// If a new access token also gets a 401, don't start the flow again. Check the Authorization header and the endpoint instead.
69
70// Step 6: Use the access token for authenticated API calls (OAuth Bearer tokens do not require Deriv-App-ID)
71const response = await fetch('https://api.derivws.com/trading/v1/options/accounts', {
72  method: 'GET',
73  headers: {
74    'Authorization': `Bearer ${accessToken}`,
75    'Content-Type': 'application/json'
76  }
77});
78
79const result = await response.json();
80console.log('Authenticated API call successful:', result);

1// Step 1: Get authenticated WebSocket URL via REST (requires authorization token)
2const otpResponse = await fetch(
3  `https://api.derivws.com/trading/v1/options/accounts/${accountId}/otp`,
4  {
5    method: 'POST',
6    headers: {
7      'Authorization': 'Bearer YOUR_AUTHORIZATION_TOKEN',  // PAT or JWT token
8      'Deriv-App-ID': 'YOUR_APP_ID'                        // Required for PAT authentication
9    }
10  }
11);
12
13const otpResult = await otpResponse.json();
14const wsUrl = otpResult.data.url;
15// The URL already includes the correct endpoint and authentication
16// Output: wss://api.derivws.com/trading/v1/options/ws/demo?otp=abc123xyz789
17
18// Step 2: Connect to WebSocket using the authenticated URL
19const ws = new WebSocket(wsUrl);
20
21ws.onopen = () => {
22  console.log('WebSocket authenticated and connected');
23  // Ready for trading operations
24};

1// After authentication...
2
3// 1. Get active symbols
4ws.send(JSON.stringify({
5  active_symbols: "brief",
6  req_id: 3
7}));
8
9// 2. Subscribe to ticks
10ws.send(JSON.stringify({
11  ticks: "1HZ100V",
12  subscribe: 1,
13  req_id: 4
14}));
15
16// 3. Get price proposal
17ws.send(JSON.stringify({
18  proposal: 1,
19  amount: 10,
20  basis: "stake",
21  contract_type: "MULTDOWN",
22  currency: "USD",
23  duration_unit: "s",
24  multiplier: 10,
25  underlying_symbol: "1HZ100V",
26  subscribe: 1,
27  req_id: 5
28}));
29
30// 4. Buy the contract (when ready)
31// Use proposal ID from previous response
32ws.send(JSON.stringify({
33  buy: "PROPOSAL_ID_HERE",
34  price: 100,
35  req_id: 6
36}));
37
38// 5. Monitor contract status
39ws.send(JSON.stringify({
40  proposal_open_contract: 1,
41  contract_id: CONTRACT_ID,
42  subscribe: 1,
43  req_id: 7
44}));

1// Connect to the public WebSocket endpoint (no authentication required)
2const ws = new WebSocket('wss://api.derivws.com/trading/v1/options/ws/public');
3
4ws.onopen = () => {
5  // Get available symbols
6  ws.send(JSON.stringify({
7    active_symbols: "brief",
8    req_id: 1
9  }));
10
11  // Subscribe to tick stream
12  ws.send(JSON.stringify({
13    ticks: "1HZ100V",
14    subscribe: 1,
15    req_id: 2
16  }));
17
18  // Get historical data
19  ws.send(JSON.stringify({
20    ticks_history: "1HZ100V",
21    count: 100,
22    end: "latest",
23    style: "ticks",
24    req_id: 3
25  }));
26};
27
28ws.onmessage = (msg) => {
29  const data = JSON.parse(msg.data);
30
31  if (data.msg_type === 'active_symbols') {
32    console.log('Available symbols:', data.active_symbols);
33  }
34
35  if (data.msg_type === 'tick') {
36    console.log('Current price:', data.tick.quote);
37  }
38
39  if (data.msg_type === 'history') {
40    console.log('Historical data:', data.history);
41  }
42};