Guia de Integração Rápida (Quick Start)

Este guia prático foi criado para ajudar você a realizar a sua primeira integração de ponta a ponta com a API BrasilSat GPS em poucos minutos.

O ciclo básico de uma integração consiste em:

Autenticar para obter um access_token temporário.
Listar Dispositivos vinculados à conta para obter os respectivos IMEIs.
Rastrear os dispositivos em tempo real passando a lista de IMEIs coletados.

Abaixo você encontra scripts funcionais prontos em Node.js e Python demonstrando exatamente como implementar esse fluxo sequencial completo.

Exemplo Completo em Node.js

O script abaixo realiza a autenticação (calculando a assinatura MD5), obtém a lista de dispositivos e faz a consulta de localização em tempo real para os primeiros dispositivos encontrados.

const crypto = require('crypto');
 
// Configurações
const BASE_URL = 'https://api.brasilsatgps.com.br';
const ACCOUNT = 'seu_usuario';
const PASSWORD = 'sua_senha';
 
// Helper para gerar hash MD5 minúsculo
function md5(text) {
  return crypto.createHash('md5').update(text).digest('hex');
}
 
async function quickStart() {
  try {
    console.log('1. Iniciando processo de autenticação...');
    const time = Math.floor(Date.now() / 1000);
    const signature = md5(md5(PASSWORD) + time);
 
    const authUrl = `${BASE_URL}/api/authorization?time=${time}&account=${ACCOUNT}&signature=${signature}`;
    const authRes = await fetch(authUrl);
    const authData = await authRes.json();
 
    if (authData.code !== 0 || !authData.record?.access_token) {
      throw new Error(`Falha na autenticação: ${JSON.stringify(authData)}`);
    }
 
    const token = authData.record.access_token;
    console.log(`✓ Autenticado com sucesso! Token: ${token.substring(0, 10)}...`);
 
    console.log('\n2. Obtendo a lista de dispositivos...');
    const listUrl = `${BASE_URL}/api/device/list?access_token=${token}`;
    const listRes = await fetch(listUrl);
    const listData = await listRes.json();
 
    if (listData.code !== 0 || !listData.record?.length) {
      console.log('Nenhum dispositivo encontrado ou erro ao listar:', listData);
      return;
    }
 
    console.log(`✓ Encontrados ${listData.record.length} dispositivos.`);
    const imeis = listData.record.slice(0, 5).map(dev => dev.imei).join(',');
    console.log(`IMEIs para rastrear (limite de 5): ${imeis}`);
 
    console.log('\n3. Consultando rastreamento em tempo real (Track)...');
    const trackUrl = `${BASE_URL}/api/track?access_token=${token}&imeis=${imeis}`;
    const trackRes = await fetch(trackUrl);
    const trackData = await trackRes.json();
 
    if (trackData.code === 0 && trackData.record) {
      console.log('✓ Dados de Rastreamento Obtidos:');
      trackData.record.forEach(device => {
        console.log(`- IMEI: ${device.imei} | Velocidade: ${device.speed} km/h | Lat: ${device.latitude} | Lng: ${device.longitude}`);
      });
    } else {
      console.log('Falha ao obter posições:', trackData);
    }
 
  } catch (error) {
    console.error('❌ Ocorreu um erro no fluxo:', error.message);
  }
}
 
quickStart();

Exemplo Completo em Python

Este script executa a mesma lógica sequencial utilizando a biblioteca padrão hashlib e a biblioteca requests para chamadas HTTP.

import hashlib
import time
import requests # Instale com: pip install requests
 
# Configurações
BASE_URL = 'https://api.brasilsatgps.com.br'
ACCOUNT = 'seu_usuario'
PASSWORD = 'sua_senha'
 
def md5(text):
    return hashlib.md5(text.encode('utf-8')).hexdigest()
 
def quick_start():
    try:
        print("1. Iniciando processo de autenticação...")
        timestamp = str(int(time.time()))
        signature = md5(md5(PASSWORD) + timestamp)
 
        auth_url = f"{BASE_URL}/api/authorization?time={timestamp}&account={ACCOUNT}&signature={signature}"
        auth_response = requests.get(auth_url).json()
 
        if auth_response.get("code") != 0 or not auth_response.get("record", {}).get("access_token"):
            print("❌ Falha na autenticação:", auth_response)
            return
 
        token = auth_response["record"]["access_token"]
        print(f"✓ Autenticado com sucesso! Token: {token[:10]}...")
 
        print("\n2. Obtendo a lista de dispositivos...")
        list_url = f"{BASE_URL}/api/device/list?access_token={token}"
        list_response = requests.get(list_url).json()
 
        if list_response.get("code") != 0 or not list_response.get("record"):
            print("Nenhum dispositivo encontrado ou erro ao listar:", list_response)
            return
 
        devices = list_response["record"]
        print(f"✓ Encontrados {len(devices)} dispositivos.")
        
        # Pegar os primeiros 5 IMEIs
        imeis_list = [device["imei"] for device in devices[:5]]
        imeis = ",".join(imeis_list)
        print(f"IMEIs para rastrear (limite de 5): {imeis}")
 
        print("\n3. Consultando rastreamento em tempo real (Track)...")
        track_url = f"{BASE_URL}/api/track?access_token={token}&imeis={imeis}"
        track_response = requests.get(track_url).json()
 
        if track_response.get("code") == 0 and track_response.get("record"):
            print("✓ Dados de Rastreamento Obtidos:")
            for device in track_response["record"]:
                print(f"- IMEI: {device['imei']} | Velocidade: {device['speed']} km/h | Lat: {device['latitude']} | Lng: {device['longitude']}")
        else:
            print("Falha ao obter posições:", track_response)
 
    except Exception as e:
        print("❌ Ocorreu um erro no fluxo:", str(e))
 
if __name__ == "__main__":
    quick_start()

Introdução Codificação de Parâmetros