Inicio Rápido

Para una integración más amigable, se muestran ejemplos de consumo a la API mediante algunos lenguajes de programación.

Buscar Certificados por RFC

cURLPHPPythonJavaScriptC#

# Configuración de credenciales (BASE64: usuario:contraseña)
USER="tu_usuario"
PASS="tu_contraseña"
CREDS=$(echo -n "$USER:$PASS" | base64)

# Todos los certificados de un RFC
curl -H "Authorization: Basic $CREDS" http://localhost:8080/by-rfc/XAXX010101000

# Solo certificados vigentes
curl -H "Authorization: Basic $CREDS" "http://localhost:8080/by-rfc/XAXX010101000?status=vigente"

# Solo certificados de tipo CSD vigentes
curl -H "Authorization: Basic $CREDS" "http://localhost:8080/by-rfc/XAXX010101000?status=vigente&type=CSD"

# Solo certificados de tipo e.firma
curl -H "Authorization: Basic $CREDS" "http://localhost:8080/by-rfc/XAXX010101000?type=e.firma"

<?php
$curl = curl_init();

// Credenciales de contratación
$usuario = "tu_usuario";
$contraseña = "tu_contraseña";
$auth = base64_encode("{$usuario}:{$contraseña}");

// Búsqueda con filtros
$rfc = "XAXX010101000";
$status = "vigente"; // opcional: vigente, vencido, revocado
$type = "CSD";       // opcional: e.firma, CSD

$url = "http://localhost:8080/by-rfc/{$rfc}";
if ($status) {
    $url .= "?status={$status}";
}
if ($type) {
    $url .= ($status ? "&" : "?") . "type={$type}";
}

curl_setopt_array($curl, [
    CURLOPT_URL => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
        "Accept: application/json",
        "Content-Type: application/json",
        "Authorization: Basic {$auth}",
    ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
    echo "cURL Error #:" . $err;
} else {
    $data = json_decode($response, true);
    echo "Total de certificados: " . $data['count'] . "\n";
    foreach ($data['certificates'] as $cert) {
        echo "Serial: " . $cert['serial_number'] . "\n";
        echo "Tipo: " . $cert['type'] . "\n";
        echo "Estado: " . $cert['status'] . "\n";
    }
}
?>

import requests
import json
from requests.auth import HTTPBasicAuth

# Configuración
base_url = "http://localhost:8080"
rfc = "XAXX010101000"
usuario = "tu_usuario"
contraseña = "tu_contraseña"

# Autenticación HTTP Basic
auth = HTTPBasicAuth(usuario, contraseña)

# Búsqueda simple
response = requests.get(f"{base_url}/by-rfc/{rfc}", auth=auth)
data = response.json()

if response.status_code == 200:
    print(f"Total de certificados encontrados: {data['count']}")
    for cert in data['certificates']:
        print(f"  - Serial: {cert['serial_number']}")
        print(f"    Tipo: {cert['type']}")
        print(f"    Estado: {cert['status']}")
else:
    print(f"Error: {data['error']['message']}")

# Búsqueda con filtros
params = {
    'status': 'vigente',
    'type': 'CSD'
}
response = requests.get(f"{base_url}/by-rfc/{rfc}", params=params, auth=auth)
data = response.json()

const baseUrl = "http://localhost:8080";
const rfc = "XAXX010101000";
const usuario = "tu_usuario";
const contraseña = "tu_contraseña";

// Codificar credenciales en Base64
const credentials = btoa(`${usuario}:${contraseña}`);

// Búsqueda simple
fetch(`${baseUrl}/by-rfc/${rfc}`, {
    headers: {
        'Authorization': `Basic ${credentials}`
    }
})
    .then(response => response.json())
    .then(data => {
        console.log(`Total de certificados: ${data.count}`);
        data.certificates.forEach(cert => {
            console.log(`Serial: ${cert.serial_number}`);
            console.log(`Tipo: ${cert.type}`);
            console.log(`Estado: ${cert.status}`);
        });
    })
    .catch(error => console.error('Error:', error));

// Búsqueda con filtros
const params = new URLSearchParams({
    status: 'vigente',
    type: 'CSD'
});

fetch(`${baseUrl}/by-rfc/${rfc}?${params}`, {
    headers: {
        'Authorization': `Basic ${credentials}`
    }
})
    .then(response => response.json())
    .then(data => console.log(data));

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Newtonsoft.Json;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        var baseUrl = "http://localhost:8080";
        var rfc = "XAXX010101000";
        var usuario = "tu_usuario";
        var contraseña = "tu_contraseña";

        // Autenticación HTTP Basic
        var credentials = Convert.ToBase64String(
            System.Text.Encoding.ASCII.GetBytes($"{usuario}:{contraseña}")
        );
        client.DefaultRequestHeaders.Authorization = 
            new AuthenticationHeaderValue("Basic", credentials);

        // Búsqueda simple
        var response = await client.GetAsync($"{baseUrl}/by-rfc/{rfc}");
        var content = await response.Content.ReadAsStringAsync();
        var data = JsonConvert.DeserializeObject<dynamic>(content);

        if (response.IsSuccessStatusCode)
        {
            Console.WriteLine($"Total de certificados: {data["count"]}");
            foreach (var cert in data["certificates"])
            {
                Console.WriteLine($"Serial: {cert["serial_number"]}");
                Console.WriteLine($"Tipo: {cert["type"]}");
                Console.WriteLine($"Estado: {cert["status"]}");
            }
        }
        else
        {
            Console.WriteLine($"Error: {data["error"]["message"]}");
        }
    }
}

Respuesta Exitosa

Una consulta exitosa retorna un objeto JSON con la siguiente estructura:

{
  "rfc": "XAXX010101000",
  "count": 2,
  "certificates": [
    {
      "rfc": "XAXX010101000",
      "serial_number": "00001000000500000001",
      "type": "CSD",
      "status": "vigente",
      "subject_name": "NOMBRE DEL CONTRIBUYENTE",
      "issuer": "",
      "valid_from": "2023-01-15T00:00:00+00:00",
      "valid_to": "2027-01-15T00:00:00+00:00",
      "email": null,
      "certificate_url": "/RecuperacionDeCertificados/...",
      "is_valid": true
    },
    {
      "rfc": "XAXX010101000",
      "serial_number": "00001000000500000002",
      "type": "e.firma",
      "status": "vigente",
      "subject_name": "NOMBRE DEL CONTRIBUYENTE",
      "issuer": "",
      "valid_from": "2022-06-10T00:00:00+00:00",
      "valid_to": "2026-06-10T00:00:00+00:00",
      "email": "usuario@empresa.com",
      "certificate_url": "/RecuperacionDeCertificados/...",
      "is_valid": true
    }
  ]
}

Manejo de Errores

Si la solicitud genera un error, la API retorna un objeto con la siguiente estructura:

{
  "error": {
    "message": "No certificates found for RFC: XAXX010101000"
  }
}

Consulta la sección de Referencia para conocer todos los códigos de error posibles.