Cómo Integrar una API de Extracción de INE en tu Sistema

Esta guía te llevará paso a paso a través del proceso de integración de una API de extracción de datos de INE en tu aplicación. Incluye ejemplos de código funcionales en Python y JavaScript.

Requisitos previos

Antes de comenzar, necesitas:

1. Una cuenta en extraerdatosdeine.com
2. Tu API Key (disponible en el panel de control)
3. Conocimientos básicos de programación (Python, JavaScript o similar)

Paso 1: Obtener tu API Key

1. Regístrate en extraerdatosdeine.com
2. Inicia sesión en tu panel de control
3. Ve a la sección "API Keys"
4. Crea una nueva API Key
5. Guarda la clave de forma segura (no la compartas)

Paso 2: Configurar tu entorno

Python

# Crear entorno virtual
python -m venv venv
source venv/bin/activate  # Linux/Mac
# o
venv\Scripts\activate  # Windows

# Instalar dependencias
pip install requests pillow

Node.js

# Inicializar proyecto
npm init -y

# Instalar dependencias
npm install axios

Paso 3: Autenticación con la API

La API usa autenticación Bearer Token. Tu API Key debe enviarse en el header de cada petición.

Python

import requests
import base64

API_KEY = "tu_api_key_aqui"
BASE_URL = "https://api.extraerdatosdeine.com/v1"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

JavaScript

const axios = require('axios');

const API_KEY = 'tu_api_key_aqui';
const BASE_URL = 'https://api.extraerdatosdeine.com/v1';

const apiClient = axios.create({
    baseURL: BASE_URL,
    headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
    }
});

Paso 4: Preparar la imagen

La imagen debe enviarse en formato Base64.

Python

import base64

def imagen_a_base64(ruta_imagen):
    """Convierte una imagen a Base64"""
    with open(ruta_imagen, "rb") as archivo:
        return base64.b64encode(archivo.read()).decode("utf-8")

# Uso
imagen_base64 = imagen_a_base64("credencial_ine.jpg")

JavaScript (Node.js)

const fs = require('fs');

function imagenABase64(rutaImagen) {
    const imagen = fs.readFileSync(rutaImagen);
    return imagen.toString('base64');
}

// Uso
const imagenBase64 = imagenABase64('credencial_ine.jpg');

JavaScript (Navegador)

function imagenABase64(file) {
    return new Promise((resolve, reject) => {
        const reader = new FileReader();
        reader.onload = () => {
            // Remover el prefijo "data:image/...;base64,"
            const base64 = reader.result.split(',')[1];
            resolve(base64);
        };
        reader.onerror = reject;
        reader.readAsDataURL(file);
    });
}

// Uso con input file
document.getElementById('inputArchivo').addEventListener('change', async (e) => {
    const archivo = e.target.files[0];
    const base64 = await imagenABase64(archivo);
    console.log('Imagen lista para enviar');
});

Paso 5: Hacer la petición de extracción

Python - Función completa

import requests
import base64

def extraer_datos_ine(ruta_imagen, lado="frente"):
    """
    Extrae datos de una credencial INE

    Args:
        ruta_imagen: Ruta al archivo de imagen
        lado: "frente" o "reverso"

    Returns:
        dict con los datos extraídos
    """
    API_KEY = "tu_api_key_aqui"
    URL = "https://api.extraerdatosdeine.com/v1/extract"

    # Preparar imagen
    with open(ruta_imagen, "rb") as f:
        imagen_base64 = base64.b64encode(f.read()).decode("utf-8")

    # Preparar petición
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }

    payload = {
        "image": imagen_base64,
        "side": lado
    }

    # Hacer petición
    response = requests.post(URL, headers=headers, json=payload)

    # Manejar respuesta
    if response.status_code == 200:
        return response.json()
    else:
        raise Exception(f"Error {response.status_code}: {response.text}")

# Uso
try:
    datos = extraer_datos_ine("mi_ine.jpg", lado="frente")
    print(datos)
except Exception as e:
    print(f"Error: {e}")

JavaScript/Node.js - Función completa

const axios = require('axios');
const fs = require('fs');

async function extraerDatosINE(rutaImagen, lado = 'frente') {
    const API_KEY = 'tu_api_key_aqui';
    const URL = 'https://api.extraerdatosdeine.com/v1/extract';

    // Preparar imagen
    const imagen = fs.readFileSync(rutaImagen);
    const imagenBase64 = imagen.toString('base64');

    // Hacer petición
    try {
        const response = await axios.post(URL, {
            image: imagenBase64,
            side: lado
        }, {
            headers: {
                'Authorization': `Bearer ${API_KEY}`,
                'Content-Type': 'application/json'
            }
        });

        return response.data;
    } catch (error) {
        throw new Error(`Error: ${error.response?.data || error.message}`);
    }
}

// Uso
(async () => {
    try {
        const datos = await extraerDatosINE('mi_ine.jpg', 'frente');
        console.log(JSON.stringify(datos, null, 2));
    } catch (error) {
        console.error(error.message);
    }
})();

Paso 6: Procesar la respuesta

La API devuelve un JSON estructurado:

{
    "success": true,
    "data": {
        "nombre": "MARGARITA",
        "apellidoPaterno": "GOMEZ",
        "apellidoMaterno": "VELAZQUEZ",
        "nombreCompleto": "MARGARITA GOMEZ VELAZQUEZ",
        "curp": "GOVM800705MCLRLR01",
        "claveElector": "GMVLMR80070501M100",
        "fechaNacimiento": "05/07/1980",
        "sexo": "M",
        "domicilio": {
            "calle": "Viaducto Tlalpan 100",
            "colonia": "Arenal Tepepan",
            "codigoPostal": "14610",
            "municipio": "TLALPAN",
            "estado": "CDMX"
        },
        "seccion": "0001",
        "vigencia": "2029"
    },
    "confidence": 0.97,
    "processingTime": 1.24
}

Mapear a tu modelo de datos

def mapear_a_cliente(datos_ine):
    """Mapea los datos de INE a tu modelo de Cliente"""
    data = datos_ine.get('data', {})
    domicilio = data.get('domicilio', {})

    return {
        'nombre_completo': data.get('nombreCompleto'),
        'curp': data.get('curp'),
        'fecha_nacimiento': data.get('fechaNacimiento'),
        'genero': 'Femenino' if data.get('sexo') == 'M' else 'Masculino',
        'direccion': f"{domicilio.get('calle')}, {domicilio.get('colonia')}",
        'codigo_postal': domicilio.get('codigoPostal'),
        'ciudad': domicilio.get('municipio'),
        'estado': domicilio.get('estado'),
        'documento_vigente': int(data.get('vigencia', 0)) >= 2026
    }

Paso 7: Manejo de errores

Códigos de respuesta

Código	Significado	Acción recomendada
200	Éxito	Procesar datos
400	Imagen inválida	Verificar formato/calidad
401	API Key inválida	Verificar credenciales
402	Sin créditos	Recargar cuenta
413	Imagen muy grande	Reducir tamaño (<5MB)
422	No se pudo extraer	Solicitar mejor imagen
429	Rate limit excedido	Esperar y reintentar
500	Error del servidor	Reintentar

Implementación con reintentos

import time

def extraer_con_reintentos(imagen, max_intentos=3):
    """Extrae datos con reintentos automáticos"""
    ultimo_error = None

    for intento in range(max_intentos):
        try:
            resultado = extraer_datos_ine(imagen)
            if resultado.get('success'):
                return resultado
        except Exception as e:
            ultimo_error = e
            if intento < max_intentos - 1:
                # Espera exponencial
                time.sleep(2 ** intento)

    raise ultimo_error or Exception("Máximo de intentos alcanzado")

Paso 8: Integración en aplicación web

Backend (Flask/Python)

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/api/extraer-ine', methods=['POST'])
def extraer_ine():
    data = request.json
    imagen_base64 = data.get('imagen')
    lado = data.get('lado', 'frente')

    if not imagen_base64:
        return jsonify({'error': 'Imagen requerida'}), 400

    try:
        resultado = extraer_datos_ine_base64(imagen_base64, lado)
        return jsonify(resultado)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(debug=True)

Frontend (HTML/JavaScript)

<!DOCTYPE html>
<html>
<head>
    <title>Captura de INE</title>
</head>
<body>
    <h1>Sube tu credencial INE</h1>

    <input type="file" id="inputINE" accept="image/*" capture="environment">
    <button onclick="procesarINE()">Extraer datos</button>

    <div id="resultado"></div>

    <script>
    async function procesarINE() {
        const input = document.getElementById('inputINE');
        const archivo = input.files[0];

        if (!archivo) {
            alert('Selecciona una imagen');
            return;
        }

        // Convertir a base64
        const base64 = await new Promise((resolve) => {
            const reader = new FileReader();
            reader.onload = () => resolve(reader.result.split(',')[1]);
            reader.readAsDataURL(archivo);
        });

        // Enviar al backend
        try {
            const response = await fetch('/api/extraer-ine', {
                method: 'POST',
                headers: {'Content-Type': 'application/json'},
                body: JSON.stringify({imagen: base64, lado: 'frente'})
            });

            const datos = await response.json();

            document.getElementById('resultado').innerHTML = `
                <h2>Datos extraídos:</h2>
                <p><strong>Nombre:</strong> ${datos.data.nombreCompleto}</p>
                <p><strong>CURP:</strong> ${datos.data.curp}</p>
                <p><strong>Vigencia:</strong> ${datos.data.vigencia}</p>
            `;
        } catch (error) {
            alert('Error al procesar: ' + error.message);
        }
    }
    </script>
</body>
</html>

Checklist de integración

• API Key configurada y guardada de forma segura
• Manejo de errores implementado
• Validación de imagen antes de enviar
• Mapeo de datos a tu modelo
• Logs para debugging
• Manejo de reintentos
• Límites de tamaño de archivo
• Feedback al usuario durante el proceso
• Tests de integración

Conclusión

Integrar una API de extracción de INE es un proceso directo que puede completarse en pocas horas. La clave está en manejar correctamente los casos de error y proporcionar una buena experiencia al usuario final.

¿Listo para integrar? Extraer Datos de INE incluye documentación completa, ejemplos de código y soporte técnico. Comienza con 20 extracciones gratis.