JavaScript

class FunBypass {
  constructor(clientKey) {
    this.clientKey = clientKey;
    this.baseUrl = "https://api.funbypass.com";
  }

  async getBalance() {
    const resp = await fetch(`${this.baseUrl}/getBalance`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ clientKey: this.clientKey }),
    });
    const data = await resp.json();
    if (data.errorId !== 0) throw new Error(data.errorCode);
    return data.balance;
  }

  async createTask(taskParams) {
    const resp = await fetch(`${this.baseUrl}/createTask`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        clientKey: this.clientKey,
        task: { type: "FunCaptchaTask", ...taskParams },
      }),
    });
    const data = await resp.json();
    if (data.errorId !== 0) throw new Error(data.errorCode);
    return data.taskId;
  }

  async getTaskResult(taskId, interval = 500, timeout = 300000) {
    const start = Date.now();
    while (Date.now() - start < timeout) {
      const resp = await fetch(`${this.baseUrl}/getTaskResult/${taskId}`);
      const data = await resp.json();

      if (data.status === "ready") {
        if (data.errorId === 0) return data.solution.token;
        throw new Error(data.errorCode);
      }

      if (data.status === "failure") {
        throw new Error(data.errorCode || "UNKNOWN_ERROR");
      }

      await new Promise((r) => setTimeout(r, interval));
    }
    throw new Error("TIMEOUT");
  }

  async runTask(taskParams) {
    const taskId = await this.createTask(taskParams);
    return this.getTaskResult(taskId);
  }
}

// Usage
const client = new FunBypass("FUN-your-api-key");

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

// Run a task
const resultToken = await client.runTask({
  websiteURL: "https://example.com",
  websitePublicKey: "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
  websiteSubdomain: "client-api",
  proxy: "http://user:pass@1.2.3.4:8080",
});
console.log(`Result token: ${resultToken}`);

// Backend proxy endpoint (Express.js example)
app.post("/api/task-result", async (req, res) => {
  const client = new FunBypass(process.env.FUNBYPASS_API_KEY);

  try {
    const resultToken = await client.runTask({
      websiteURL: req.body.websiteURL,
      websitePublicKey: req.body.websitePublicKey,
      websiteSubdomain: req.body.websiteSubdomain,
      proxy: req.body.proxy,
    });
    res.json({ token: resultToken });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

async function processBatch(client, tasks, concurrency = 10) {
  const results = [];
  const queue = [...tasks];

  const workers = Array.from({ length: concurrency }, async () => {
    while (queue.length > 0) {
      const task = queue.shift();
      try {
        const resultToken = await client.runTask(task);
        results.push({ success: true, token: resultToken });
      } catch (err) {
        results.push({ success: false, error: err.message });
      }
    }
  });

  await Promise.all(workers);
  return results;
}

// Process 50 tasks with 10 concurrent workers
const tasks = Array.from({ length: 50 }, () => ({
  websiteURL: "https://example.com",
  websitePublicKey: "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
  websiteSubdomain: "client-api",
  proxy: "http://user:pass@1.2.3.4:8080",
}));

const results = await processBatch(client, tasks, 10);
console.log(`Completed: ${results.filter((r) => r.success).length}/${results.length}`);