Listar Chaves PIX

curl --request GET \
  --url https://api-gateway.firebanking.com.br/v1/account/pix-keys \
  --header 'x-api-key: sua_chave_api'

{
  "pixKeys": [
    {
      "pixKey": "72d52e67-9b98-45e0-a20e-4c259259d271",
      "pixType": "RANDOM_KEY",
      "provider": "celcoin"
    },
    {
      "pixKey": "1d8cba66-be01-4b7f-a642-12c37535e234",
      "pixType": "RANDOM_KEY",
      "provider": "celcoin"
    },
    {
      "pixKey": "[email protected]",
      "pixType": "EMAIL",
      "provider": "celcoin"
    },
    {
      "pixKey": "12345678000190",
      "pixType": "DOCUMENT",
      "provider": "celcoin"
    }
  ]
}

{
  "pixKeys": []
}

const fetchPixKeys = async () => {
  try {
    const response = await fetch(
      'https://api-gateway.firebanking.com.br/v1/account/pix-keys',
      {
        headers: {
          'x-api-key': 'sua_chave_api'
        }
      }
    );

    const data = await response.json();

    if (data.pixKeys.length === 0) {
      console.log('Nenhuma chave PIX cadastrada');
      return;
    }

    console.log('Chaves PIX disponíveis:');
    data.pixKeys.forEach((key, index) => {
      console.log(`${index + 1}. ${key.pixKey} (${key.pixType})`);
    });

    return data.pixKeys;
  } catch (error) {
    console.error('Erro ao buscar chaves PIX:', error);
  }
};

import { useState, useEffect } from 'react';

function PixKeysSelector() {
  const [pixKeys, setPixKeys] = useState([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetchPixKeys();
  }, []);

  const fetchPixKeys = async () => {
    try {
      const response = await fetch('/v1/account/pix-keys', {
        headers: { 'x-api-key': process.env.API_KEY }
      });
      const data = await response.json();
      setPixKeys(data.pixKeys);
    } catch (error) {
      console.error('Erro ao carregar chaves:', error);
    } finally {
      setLoading(false);
    }
  };

  const copyToClipboard = (pixKey) => {
    navigator.clipboard.writeText(pixKey);
    alert('Chave PIX copiada!');
  };

  if (loading) return <div>Carregando...</div>;

  if (pixKeys.length === 0) {
    return <div>Nenhuma chave PIX cadastrada</div>;
  }

  return (
    <div>
      <h2>Minhas Chaves PIX</h2>
      {pixKeys.map((key, index) => (
        <div key={index} className="pix-key-item">
          <span>{key.pixKey}</span>
          <span className="badge">{key.pixType}</span>
          <button onClick={() => copyToClipboard(key.pixKey)}>
            Copiar
          </button>
        </div>
      ))}
    </div>
  );
}

import requests
import time
from datetime import datetime, timedelta

class PixKeysCache:
    def __init__(self, api_key, cache_duration_minutes=10):
        self.api_key = api_key
        self.cache_duration = timedelta(minutes=cache_duration_minutes)
        self.cached_keys = None
        self.last_fetch = None

    def get_pix_keys(self):
        """Retorna chaves PIX do cache ou faz nova requisição"""
        if self.is_cache_valid():
            return self.cached_keys

        return self.fetch_pix_keys()

    def is_cache_valid(self):
        """Verifica se o cache ainda é válido"""
        if not self.cached_keys or not self.last_fetch:
            return False

        return datetime.now() - self.last_fetch < self.cache_duration

    def fetch_pix_keys(self):
        """Busca chaves PIX da API"""
        response = requests.get(
            'https://api-gateway.firebanking.com.br/v1/account/pix-keys',
            headers={'x-api-key': self.api_key}
        )

        data = response.json()

        # Atualizar cache
        self.cached_keys = data['pixKeys']
        self.last_fetch = datetime.now()

        return self.cached_keys

# Uso
cache = PixKeysCache(api_key='sua_chave_api', cache_duration_minutes=10)

# Primeira chamada: busca da API
keys = cache.get_pix_keys()
print(f"Encontradas {len(keys)} chaves PIX")

# Chamadas subsequentes nos próximos 10 minutos: usa cache
keys = cache.get_pix_keys()  # Retorna do cache

const getKeysByType = (pixKeys, type) => {
  return pixKeys.filter(key => key.pixType === type);
};

const data = await fetchPixKeys();

// Buscar apenas chaves aleatórias
const randomKeys = getKeysByType(data.pixKeys, 'RANDOM_KEY');

// Buscar apenas emails
const emailKeys = getKeysByType(data.pixKeys, 'EMAIL');

// Buscar chave principal (primeira da lista)
const mainKey = data.pixKeys[0]?.pixKey;

const getKeysByProvider = (pixKeys, provider) => {
  return pixKeys.filter(key => key.provider === provider);
};

// Buscar apenas chaves do Celcoin
const celcoinKeys = getKeysByProvider(data.pixKeys, 'celcoin');

// Contar chaves por provedor
const countByProvider = (pixKeys) => {
  return pixKeys.reduce((acc, key) => {
    acc[key.provider] = (acc[key.provider] || 0) + 1;
    return acc;
  }, {});
};

console.log(countByProvider(data.pixKeys));
// Output: { celcoin: 3, woovi: 1 }

// 1. Buscar chaves PIX
const { pixKeys } = await fetchPixKeys();

// 2. Selecionar chave aleatória (mais privacidade)
const randomKey = pixKeys.find(k => k.pixType === 'RANDOM_KEY');

// 3. Criar cobrança PIX usando a chave
const charge = await fetch('/pix/v2/payment', {
  method: 'POST',
  headers: {
    'x-api-key': API_KEY,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    value: 5000, // R$ 50,00
    buyer: {
      name: 'Cliente Exemplo',
      document: '12345678901'
    },
    pixKey: randomKey.pixKey // Usar chave da conta
  })
});