Quickstart

npm install axios dotenv

pip install requests python-dotenv

require('dotenv').config();
const axios = require('axios');
const fs = require('fs');
const https = require('https');

const API_URL = process.env.FYPAY_API_URL;

const mtlsAgent = new https.Agent({
  cert: fs.readFileSync('./client.crt'),
  key: fs.readFileSync('./client.key')
});

// 1. Obter token (mTLS: certificado no handshake TLS)
async function getToken() {
  const response = await axios.post(`${API_URL}/auth/token`, {
    clientId: process.env.FYPAY_CLIENT_ID,
    clientSecret: process.env.FYPAY_CLIENT_SECRET
  }, {
    httpsAgent: mtlsAgent,
    headers: { 'Content-Type': 'application/json' }
  });
  return response.data.access_token;
}

// 2. Consultar saldo
async function getBalance(token) {
  const response = await axios.get(`${API_URL}/balance`, {
    headers: { 'Authorization': `Bearer ${token}` }
  });
  return response.data;
}

// 3. Criar cobrança PIX
async function createPixCharge(token, value, description, externalId, payer) {
  const response = await axios.post(`${API_URL}/pix/cash-in`, {
    transaction: {
      value,
      description,
      externalId,
      expirationTime: 3600, // 1 hora
      generateQrCode: true
    },
    payer: {
      fullName: payer.name,
      document: payer.document
    }
  }, {
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json'
    }
  });
  return response.data;
}

// Executar
async function main() {
  try {
    // Autenticar
    console.log('Autenticando...');
    const token = await getToken();
    console.log('Token obtido com sucesso!');

    // Consultar saldo
    console.log('\nConsultando saldo...');
    const balance = await getBalance(token);
    console.log(`Saldo disponível: R$ ${balance.netBalance.toFixed(2)}`);

    // Criar cobrança
    console.log('\nCriando cobrança PIX...');
    const charge = await createPixCharge(token, 100.00, 'Teste de integração', 'ORDER-001', {
      name: 'João da Silva',
      document: '12345678909'
    });

    console.log(`\nCobrança criada!`);
    console.log(`ID: ${charge.transactionId}`);
    console.log(`Status: ${charge.status}`);
    console.log(`PIX Copia e Cola: ${charge.pixCode}`);
    console.log(`Expira em: ${charge.expirationDate}`);

  } catch (error) {
    console.error('Erro:', error.response?.data || error.message);
  }
}

main();

import os
import requests
from dotenv import load_dotenv

load_dotenv()

API_URL = os.getenv('FYPAY_API_URL')

# 1. Obter token (mTLS: certificado no handshake TLS)
def get_token():
    response = requests.post(f'{API_URL}/auth/token',
        json={
            'clientId': os.getenv('FYPAY_CLIENT_ID'),
            'clientSecret': os.getenv('FYPAY_CLIENT_SECRET')
        },
        cert=('client.crt', 'client.key')
    )
    response.raise_for_status()
    return response.json()['access_token']

# 2. Consultar saldo
def get_balance(token):
    response = requests.get(f'{API_URL}/balance',
        headers={'Authorization': f'Bearer {token}'}
    )
    response.raise_for_status()
    return response.json()

# 3. Criar cobrança PIX
def create_pix_charge(token, value, description, external_id, payer_name, payer_document):
    response = requests.post(f'{API_URL}/pix/cash-in',
        json={
            'transaction': {
                'value': value,
                'description': description,
                'externalId': external_id,
                'expirationTime': 3600,
                'generateQrCode': True
            },
            'payer': {
                'fullName': payer_name,
                'document': payer_document
            }
        },
        headers={
            'Authorization': f'Bearer {token}',
            'Content-Type': 'application/json'
        }
    )
    response.raise_for_status()
    return response.json()

# Executar
def main():
    try:
        # Autenticar
        print('Autenticando...')
        token = get_token()
        print('Token obtido com sucesso!')

        # Consultar saldo
        print('\nConsultando saldo...')
        balance = get_balance(token)
        print(f"Saldo disponível: R$ {balance['netBalance']:.2f}")

        # Criar cobrança
        print('\nCriando cobrança PIX...')
        charge = create_pix_charge(
            token,
            100.00,
            'Teste de integração',
            'ORDER-001',
            'João da Silva',
            '12345678909'
        )

        print(f"\nCobrança criada!")
        print(f"ID: {charge['transactionId']}")
        print(f"Status: {charge['status']}")
        print(f"PIX Copia e Cola: {charge['pixCode']}")
        print(f"Expira em: {charge['expirationDate']}")

    except requests.exceptions.RequestException as e:
        print(f'Erro: {e.response.json() if e.response else e}')

if __name__ == '__main__':
    main()

node quickstart.js

python quickstart.py