API Authentication Guide

import requests
from datetime import datetime, timedelta

class OptionsPlayClient:
    def __init__(self, client_id, client_secret):
        self.client_id = client_id
        self.client_secret = client_secret
        self.base_url = "https://app.optionsplay.com"
        self.token = None
        self.token_expiry = None
    
    def _get_token(self):
        """Acquire or refresh OAuth token"""
        if self.token and self.token_expiry > datetime.now():
            return self.token
        
        response = requests.post(
            f"{self.base_url}/token",
            data={
                "grant_type": "client_credentials",
                "client_id": self.client_id,
                "client_secret": self.client_secret
            }
        )
        response.raise_for_status()
        data = response.json()
        
        self.token = data["access_token"]
        self.token_expiry = datetime.now() + timedelta(seconds=data["expires_in"] - 60)
        return self.token
    
    def get_why(self, symbol):
        """Get trade ideas for a symbol"""
        token = self._get_token()
        response = requests.get(
            f"{self.base_url}/api/v1/platform/why/{symbol}",
            headers={"Authorization": f"Bearer {token}"}
        )
        response.raise_for_status()
        return response.json()

# Usage
client = OptionsPlayClient("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")
data = client.get_why("AAPL")

class OptionsPlayClient {
  constructor(clientId, clientSecret) {
    this.clientId = clientId;
    this.clientSecret = clientSecret;
    this.baseUrl = 'https://app.optionsplay.com';
    this.token = null;
    this.tokenExpiry = null;
  }

  async getToken() {
    // Return cached token if still valid
    if (this.token && this.tokenExpiry > Date.now()) {
      return this.token;
    }

    const response = await fetch(`${this.baseUrl}/token`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: new URLSearchParams({
        grant_type: 'client_credentials',
        client_id: this.clientId,
        client_secret: this.clientSecret
      })
    });

    if (!response.ok) throw new Error('Token acquisition failed');
    
    const data = await response.json();
    this.token = data.access_token;
    this.tokenExpiry = Date.now() + (data.expires_in - 60) * 1000;
    return this.token;
  }

  async getWhy(symbol) {
    const token = await this.getToken();
    const response = await fetch(
      `${this.baseUrl}/api/v1/platform/why/${symbol}`,
      { headers: { 'Authorization': `Bearer ${token}` } }
    );
    
    if (!response.ok) throw new Error('API request failed');
    return response.json();
  }
}

// Usage
const client = new OptionsPlayClient('YOUR_CLIENT_ID', 'YOUR_CLIENT_SECRET');
const data = await client.getWhy('AAPL');

public class OptionsPlayClient
{
    private readonly string _clientId;
    private readonly string _clientSecret;
    private readonly string _baseUrl = "https://app.optionsplay.com";
    private readonly HttpClient _httpClient;
    private string _token;
    private DateTime _tokenExpiry;

    public OptionsPlayClient(string clientId, string clientSecret)
    {
        _clientId = clientId;
        _clientSecret = clientSecret;
        _httpClient = new HttpClient();
    }

    private async Task<string> GetTokenAsync()
    {
        if (_token != null && _tokenExpiry > DateTime.UtcNow)
            return _token;

        var content = new FormUrlEncodedContent(new[]
        {
            new KeyValuePair<string, string>("grant_type", "client_credentials"),
            new KeyValuePair<string, string>("client_id", _clientId),
            new KeyValuePair<string, string>("client_secret", _clientSecret)
        });

        var response = await _httpClient.PostAsync($"{_baseUrl}/token", content);
        response.EnsureSuccessStatusCode();

        var json = await response.Content.ReadAsStringAsync();
        var tokenResponse = JsonSerializer.Deserialize<TokenResponse>(json);

        _token = tokenResponse.AccessToken;
        _tokenExpiry = DateTime.UtcNow.AddSeconds(tokenResponse.ExpiresIn - 60);
        return _token;
    }

    public async Task<string> GetWhyAsync(string symbol)
    {
        var token = await GetTokenAsync();
        _httpClient.DefaultRequestHeaders.Authorization = 
            new AuthenticationHeaderValue("Bearer", token);

        var response = await _httpClient.GetAsync(
            $"{_baseUrl}/api/v1/platform/why/{symbol}");
        response.EnsureSuccessStatusCode();

        return await response.Content.ReadAsStringAsync();
    }
}

// Usage
var client = new OptionsPlayClient("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
var data = await client.GetWhyAsync("AAPL");

import requests

class OptionsPlayClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://apis.optionsplay.com"
    
    def get_why(self, symbol):
        """Get trade ideas for a symbol"""
        response = requests.get(
            f"{self.base_url}/api/v1/platform/why/{symbol}",
            headers={"Op-Subscription-Key": self.api_key}
        )
        response.raise_for_status()
        return response.json()

# Usage - that's it!
client = OptionsPlayClient("YOUR_API_KEY")
data = client.get_why("AAPL")

class OptionsPlayClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://apis.optionsplay.com';
  }

  async getWhy(symbol) {
    const response = await fetch(
      `${this.baseUrl}/api/v1/platform/why/${symbol}`,
      { headers: { 'Op-Subscription-Key': this.apiKey } }
    );
    
    if (!response.ok) throw new Error('API request failed');
    return response.json();
  }
}

// Usage - that's it!
const client = new OptionsPlayClient('YOUR_API_KEY');
const data = await client.getWhy('AAPL');

public class OptionsPlayClient
{
    private readonly string _apiKey;
    private readonly string _baseUrl = "https://apis.optionsplay.com";
    private readonly HttpClient _httpClient;

    public OptionsPlayClient(string apiKey)
    {
        _apiKey = apiKey;
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Add("Op-Subscription-Key", _apiKey);
    }

    public async Task<string> GetWhyAsync(string symbol)
    {
        var response = await _httpClient.GetAsync(
            $"{_baseUrl}/api/v1/platform/why/{symbol}");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}

// Usage - that's it!
var client = new OptionsPlayClient("YOUR_API_KEY");
var data = await client.GetWhyAsync("AAPL");