POST /stream/token
Content-Type: application/json
Authorization: Bearer YOUR_API_KEY

{
  "token": "a1b2c3d4e5f6789012345678901234567890abcdef",
  "expiresIn": 86400
}

const axios = require("axios");

async function generateSSEToken(apiKey) {
  try {
    const response = await axios.post(
      "https://scrape.st/stream/token",
      {},
      {
        headers: {
          "x-api-key": apiKey,
          "Content-Type": "application/json",
        },
      },
    );

    return response.data;
  } catch (error) {
    console.error("Token generation failed:", error.response?.data || error.message);
    throw error;
  }
}

// Usage
const tokenData = await generateSSEToken("your_api_key_here");
console.log("Token:", tokenData.token);
console.log("Expires in:", tokenData.expiresIn, "seconds");

import requests
import json

def generate_sse_token(api_key):
    url = "https://scrape.st/stream/token"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }

    try:
        response = requests.post(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as error:
        print(f"Token generation failed: {error}")
        raise

# Usage
token_data = generate_sse_token("your_api_key_here")
print(f"Token: {token_data['token']}")
print(f"Expires in: {token_data['expiresIn']} seconds")

curl -X POST https://scrape.st/stream/token \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

{
  "error": "Invalid API key",
  "code": 401
}

{
  "error": "Rate limit exceeded. Maximum 10 tokens per hour.",
  "code": 429,
  "retryAfter": 3600
}

{
  "error": "Internal server error",
  "code": 500
}

class SSETokenManager {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.token = null;
    this.expiresAt = null;
  }

  async getValidToken() {
    // Check if current token is valid
    if (this.token && this.expiresAt && Date.now() < this.expiresAt) {
      return this.token;
    }

    // Generate new token
    const tokenData = await generateSSEToken(this.apiKey);
    this.token = tokenData.token;
    this.expiresAt = Date.now() + tokenData.expiresIn * 1000;

    return this.token;
  }

  async refreshToken() {
    this.token = null;
    this.expiresAt = null;
    return this.getValidToken();
  }
}

async function connectPrivateSSEWithTokenRefresh(apiKey) {
  const tokenManager = new SSETokenManager(apiKey);

  function connect() {
    tokenManager
      .getValidToken()
      .then((token) => {
        const eventSource = new EventSource(`https://scrape.st/sse/private?token=${token}`);

        eventSource.onerror = async (error) => {
          if (eventSource.readyState === EventSource.CLOSED) {
            console.log("Connection closed, refreshing token...");
            await tokenManager.refreshToken();
            setTimeout(connect, 5000); // Reconnect after delay
          }
        };

        eventSource.onmessage = (event) => {
          const data = JSON.parse(event.data);
          console.log("Received data:", data);
        };

        return eventSource;
      })
      .catch((error) => {
        console.error("Failed to connect:", error);
        setTimeout(connect, 10000); // Retry after longer delay
      });
  }

  connect();
}