Documentação

Conexão em tempo real

Os resultados são transmitidos por WebSocket seguro.

Endpoint

"wss://apiscb.site/"

Provedores suportados

Os resultados chegam por provedor e jogo/canal. Abaixo estão os provedores atualmente suportados.

Provedor	Exemplos de canais/jogos
Evolution	`evobacbo`, `evofutebolstudio`, `evodragontiger`
Pragmatic Play	`pragdragontiger`, `pragsicbo`, `pragspaceman`
Blaze	`blazcrash`, `blazdouble`, `blazfortunedouble`
Playtech	Canais liberados conforme plano
CreedRoomz	Canais liberados conforme plano

Autenticação

Use seu token no handshake/autorização da conexão.

Bearer Token

Authorization: Bearer "SEU_TOKEN_AQUI"

Exemplo de mensagem recebida

Formato enviado em tempo real via WebSocket para cada novo resultado.

JSON

{
  "jogo": "evobacbo",
  "novoRegistro": {
    "hora": "2025-11-19 19:47:08",
    "resultado": "V",
    "multiplicador": 2,
    "numero_banker": 9,
    "numero_player": 8,
    "dado_banker1": 3,
    "dado_banker2": 6,
    "dado_player1": 4,
    "dado_player2": 4,
    "numero": "09"
  }
}

Tipos de resposta

Tipo	Descrição
novoRegistro	Novo resultado do jogo (resultado, número e hora).
sucesso	Informações iniciais de conexão/token autorizado.
erro	Erro retornado pelo servidor durante a conexão.

Script - Monitoramento de Múltiplos Jogos

JavaScript

import WebSocket from "ws"

const HOST = "apiscb.site"
const TOKEN = "SEU_TOKEN"
const WS_URL = `wss://${HOST}/?token=${TOKEN}`

function conectar() {
  const ws = new WebSocket(WS_URL)

  ws.on("open", () => {
    console.log(`✅ Conectado ao WebSocket com token "${TOKEN}" (monitorando todos os jogos)`)
  })

  ws.on("message", (data) => {
    try {
      const msg = JSON.parse(data)

      if (msg.jogo && msg.novoRegistro) {
        const r = msg.novoRegistro
        console.log(`🎯 RESULTADO: [${r.resultado}] - [${r.numero}] | [${msg.jogo}] `)
      }
      else if (msg.erro) {
        console.error("❌ Erro do servidor:", msg.erro)
      }
      else if (msg.sucesso) {
        console.log("ℹ️ Status:", msg.sucesso)
        if (msg.conexoes_restantes !== undefined && msg.validade) {
          console.log(`🔗 Conexões restantes: ${msg.conexoes_restantes}`)
          console.log(`⏱️ Validade do token: ${msg.validade}`)
        }
      }

    } catch (err) {
      console.error("⚠️ Erro ao ler mensagem:", err)
    }
  })

  ws.on("close", () => {
    console.log("❌ Conexão fechada, tentando reconectar em 3s...")
    setTimeout(conectar, 3000)
  })

  ws.on("error", (err) => {
    console.error("⚠️ Erro no WebSocket:", err)
  })
}

conectar()

Script - Monitoramento de Apenas 1 Jogo

JavaScript

import WebSocket from "ws"

const HOST = "apiscb.site"
const TOKEN = "SEU_TOKEN"
const JOGO = "evobacbo"

const WS_URL = `wss://${HOST}/?token=${TOKEN}`

function conectar() {
  const ws = new WebSocket(WS_URL)

  ws.on("open", () => {
    console.log(`✅ Conectado ao WebSocket para o jogo "${JOGO}" com token "${TOKEN}"`)
  })

  ws.on("message", (data) => {
    try {
      const msg = JSON.parse(data)

      if (msg.jogo === JOGO && msg.novoRegistro) {
        const r = msg.novoRegistro
        console.log(`📥 RESULTADO: [${r.resultado}] - [${r.numero}] | ${r.hora}`)
      }
      else if (msg.erro) {
        console.error("❌ Erro do servidor:", msg.erro)
      }
      else if (msg.sucesso) {
        console.log("ℹ️ Status:", msg.sucesso)
        if (msg.conexoes_restantes !== undefined && msg.validade) {
          console.log(`🔗 Conexões restantes: ${msg.conexoes_restantes}`)
          console.log(`⏱️ Validade do token: ${msg.validade}`)
        }
      }

    } catch (err) {
      console.error("Erro ao ler mensagem:", err)
    }
  })

  ws.on("close", () => {
    console.log("❌ Conexão fechada, tentando reconectar em 3s...")
    setTimeout(conectar, 3000)
  })

  ws.on("error", (err) => {
    console.error("⚠️ Erro no WebSocket:", err)
  })
}

conectar()

Script - Bot + Estratégia (WebSocket + Telegram)

JavaScript

import WebSocket from 'ws'

const HOST = 'apiscb.site'
const TOKEN = 'SEU_TOKEN_API'
const JOGO = 'blazedouble'

const TG_BOT_TOKEN = 'TOKEN_DO_SEU_BOT'
const TG_CHAT_ID = 'ID_DO_SEU_CHAT'

const WS_URL = `wss://${HOST}/?token=${TOKEN}`

let banca = 100.0
let baseBet = 1.0
let max_gale = 3

let entrada = 0
let erros = 0
let acertos = 0

let analise_sinal = false
let alvo = null
let stake = 0
let perdas = 0
let gale = 0

let ultimoNumero = null

const sleep = (ms) => new Promise((r) => setTimeout(r, ms))

const r2 = (v) => Math.round((Number(v) + Number.EPSILON) * 100) / 100
const ceil2 = (v) => Math.ceil(Number(v) * 100) / 100

const multDoAlvo = (a) => (a === 'B' ? 14 : 2)
const emoDoAlvo = (a) => (a === 'P' ? '⚫' : a === 'V' ? '🔴' : '⚪️')

const enviarMenssagem = async (text) => {
  try {
    const url =
      `https://api.telegram.org/bot${TG_BOT_TOKEN}/sendMessage?chat_id=${encodeURIComponent(TG_CHAT_ID)}&text=${encodeURIComponent(text)}`
    await fetch(url, { method: 'GET', signal: AbortSignal.timeout(20000) })
  } catch {}
}

const enviarStatus = async () => {
  const p1 = '📊 PARCIAIS 📈'
  const p2 = '✅ WINS: ' + String(acertos)
  const p3 = '❌ LOSS: ' + String(erros)
  const p4 = '💰 SALDO: R$' + r2(banca).toFixed(2)
  await enviarMenssagem(p1 + '\n\n' + p2 + '\n' + p3 + '\n\n' + p4)
}

const iniciarEntrada = async (novoAlvo, motivo) => {
  if (analise_sinal) return
  alvo = novoAlvo
  analise_sinal = true
  perdas = 0
  gale = 0
  entrada = 0

  stake = baseBet
  if (banca < stake) {
    analise_sinal = false
    return
  }
  banca = r2(banca - stake)

  const p1 = '🔰 OPORTUNIDADE ENCONTRADA!'
  const p2 = '➡️ ENTRADA NO: ' + emoDoAlvo(alvo)
  const p3 = '🚥 APÓS: ' + String(motivo ?? '')
  const p4 = '🎯 ALVO: ' + alvo + ' | APOSTA: R$' + r2(stake).toFixed(2)
  const p5 = '💰 BANCA: R$' + r2(banca).toFixed(2)

  await enviarMenssagem(p1 + '\n\n' + p2 + '\n' + p3 + '\n\n' + p4 + '\n' + p5)
}

const proximaStake = () => {
  const mult = multDoAlvo(alvo)
  const denom = mult - 1
  const alvoLucro = baseBet
  const need = perdas + alvoLucro
  return ceil2(need / denom)
}

const irGale = async () => {
  gale += 1
  entrada = gale
  if (gale <= max_gale) {
    stake = proximaStake()
    if (banca < stake) {
      erros += 1
      analise_sinal = false
      await enviarMenssagem('❌❌❌ LOSS ❌❌❌\n💣 BANCA INSUFICIENTE')
      await enviarStatus()
      return
    }
    banca = r2(banca - stake)
    await enviarMenssagem(
      '⚠️ VAMOS AO G' +
        String(gale) +
        '\n🎯 ALVO: ' +
        alvo +
        ' ' +
        emoDoAlvo(alvo) +
        '\n💵 APOSTA: R$' +
        r2(stake).toFixed(2) +
        '\n💰 BANCA: R$' +
        r2(banca).toFixed(2)
    )
  } else {
    erros += 1
    analise_sinal = false
    await enviarMenssagem('❌❌❌ LOSS ❌❌❌')
    await enviarStatus()
  }
}

const tratarResultado = async (resultado) => {
  if (!analise_sinal) return

  if (resultado === alvo) {
    const mult = multDoAlvo(alvo)
    const retorno = r2(stake * mult)
    banca = r2(banca + retorno)

    acertos += 1
    analise_sinal = false

    await enviarMenssagem(
      '✅✅✅ WINN ✅✅✅' +
        '\n🎯 ALVO: ' +
        alvo +
        ' ' +
        emoDoAlvo(alvo) +
        '\n🧾 RETORNO: R$' +
        r2(retorno).toFixed(2) +
        '\n💰 BANCA: R$' +
        r2(banca).toFixed(2)
    )
    await enviarStatus()
  } else {
    perdas = r2(perdas + stake)
    await irGale()
  }
}

const tentarSinal = async (numero, resultado) => {
  if (analise_sinal) return
  if (numero == null) return

  if (numero >= 1 && numero <= 7) {
    await iniciarEntrada('P', resultado)
  } else if (numero >= 8 && numero <= 14) {
    await iniciarEntrada('V', resultado)
  } else if (numero === 0) {
    await iniciarEntrada('B', resultado)
  }
}

function conectar() {
  const ws = new WebSocket(WS_URL)

  ws.on('open', async () => {
    console.log(`✅ Conectado ao WebSocket para o jogo "${JOGO}" com token "${TOKEN}"`)
    await enviarMenssagem(`⚡ BOT INICIADO - BANCA: R$${banca} | ANALISANDO! 📈`)
  })

  ws.on('message', async (data) => {
    try {
      const raw = Buffer.isBuffer(data) ? data.toString('utf8') : String(data)
      const msg = JSON.parse(raw)

      if (msg.jogo === JOGO && msg.novoRegistro) {
        const r = msg.novoRegistro
        const resultado = String(r.resultado || '').trim().toUpperCase()
        const numero = Number.parseInt(String(r.numero ?? ''), 10)

        if (!resultado || (resultado !== 'P' && resultado !== 'V' && resultado !== 'B')) return
        if (!Number.isFinite(numero)) return
        if (String(r.hora || '') === String(ultimoNumero || '')) return
        ultimoNumero = String(r.hora || '')

        console.log(`📥 RESULTADO: [${r.resultado}] - [${r.numero}] | ${r.hora}`)

        if (analise_sinal) {
          await tratarResultado(resultado)
        } else {
          await tentarSinal(numero, resultado)
        }
      } else if (msg.erro) {
        console.error('❌ Erro do servidor:', msg.erro)
      } else if (msg.sucesso) {
        console.log('ℹ️ Status:', msg.sucesso)
        if (msg.conexoes_restantes !== undefined && msg.validade) {
          console.log(`🔗 Conexões restantes: ${msg.conexoes_restantes}`)
          console.log(`⏱️ Validade do token: ${msg.validade}`)
        }
      }
    } catch (err) {
      console.error('Erro ao ler mensagem:', err)
    }
  })

  ws.on('close', () => {
    console.log('❌ Conexão fechada, tentando reconectar em 3s...')
    setTimeout(conectar, 3000)
  })

  ws.on('error', (err) => {
    console.error('⚠️ Erro no WebSocket:', err)
  })
}

conectar()