Cómo crear datos de prueba API realistas

Cada prueba de API necesita datos para ejecutarse: usuarios para login, pedidos y pagos para checkout, miles de filas para paginación y filtros. Crear esos datos a mano es lento y suele producir fixtures demasiado “limpios” para encontrar errores reales.

Prueba Apidog hoy

Un generador de datos de prueba crea registros realistas y variados bajo demanda. En vez de repetir {"name": "test", "email": "[e-mail]"}, defines la forma del dato —nombre, email válido, precio entre 10 y 500— y el generador completa valores creíbles. En esta guía verás qué es un generador de datos de prueba, qué tipos existen y cómo generar datos directamente en Apidog, sin añadir otra herramienta al flujo.

Si es nuevo en la simulación de respuestas de API, empiece por qué es una API simulada y vuelva aquí para resolver la parte de los datos.

¿Qué es un generador de datos de prueba?

Un generador de datos de prueba es una herramienta o librería que produce datos sintéticos con estructura similar a la producción.

Ejemplo: en vez de escribir manualmente este payload cien veces:

{
  "name": "test",
  "email": "[e-mail]",
  "price": 10
}

defines reglas como:

{
  "name": "nombre completo",
  "email": "email válido",
  "price": "número entre 10 y 500"
}

El generador se encarga de producir valores distintos y válidos en cada ejecución.

Un buen conjunto de datos de prueba debe ser:

• Realista: los nombres parecen nombres, los emails pasan validaciones y las fechas tienen rangos razonables.
• Variado: los registros no son idénticos, lo que ayuda a detectar errores de límites, paginación y validación.
• Seguro: los datos son sintéticos, por lo que no se copian registros reales ni PII a pruebas o repositorios.

El objetivo no es crear datos “bonitos”; es mejorar la cobertura. Un generador permite probar cadenas vacías, nombres Unicode, números extremos, fechas caducadas y otros casos que suelen romper APIs.

Por qué los datos realistas importan en pruebas de API

Las APIs validan entradas, aplican reglas de negocio y devuelven respuestas distintas según los datos recibidos. Si todos sus tests usan John Doe / [e-mail] / quantity 1, solo está probando el camino feliz.

Con datos generados puede:

1. Probar volumen realista. Genere 5.000 productos para validar paginación, ordenamiento y filtros.
2. Forzar límites. Use precios 0, cantidades negativas o nombres de 256 caracteres para comprobar la validación.
3. Ejecutar pruebas basadas en datos. Pase múltiples filas por el mismo test y afirme el resultado esperado para cada caso.

Ejemplo de dataset CSV para una prueba de creación de usuario:

name,email,expectedStatus
Ana García,[e-mail],201
,[e-mail],400
Usuario Largooooooooooooooooooooooooooooooooooooooooooooooooooooooooo,[e-mail],400
李雷,[e-mail],201

Una sola prueba puede iterar sobre cada fila y validar si la API responde correctamente.

Tipos principales de generadores de datos de prueba

Los generadores suelen caer en cuatro categorías. En la práctica, muchos equipos combinan varias.

1. Librerías de código

Librerías como Faker.js para JavaScript o Faker para Python permiten generar datos desde código:

import { faker } from '@faker-js/faker';

const user = {
  id: faker.string.uuid(),
  name: faker.person.fullName(),
  email: faker.internet.email(),
  createdAt: faker.date.recent().toISOString()
};

console.log(user);

Úselas cuando necesite control programático, reproducibilidad con semillas o integración directa en scripts de test.

La desventaja: debe escribir y mantener código. Si trabaja con JavaScript, esta guía sobre Faker.js y cómo usarlo en Apidog muestra cómo aplicar esas reglas al motor de simulación de Apidog.

2. Generadores autónomos y online

Herramientas como Mockaroo permiten definir columnas desde una interfaz web y exportar CSV, JSON o SQL.

Son útiles para:

• Crear un archivo semilla rápido.
• Probar una importación.
• Generar un dataset estático sin escribir código.

Limitación: los datos quedan como una exportación fija. Si cambia el esquema, debe volver a generar y sincronizar manualmente.

3. Generadores basados en esquemas

Si ya tiene una especificación OpenAPI o JSON Schema, puede generar datos a partir del contrato.

Ejemplo de esquema:

{
  "type": "object",
  "properties": {
    "id": { "type": "string", "format": "uuid" },
    "email": { "type": "string", "format": "email" },
    "age": { "type": "integer", "minimum": 18, "maximum": 99 }
  },
  "required": ["id", "email"]
}

Un generador basado en esquema puede producir datos que respeten tipos, formatos y restricciones. Esto mantiene los datos de prueba alineados con la API.

Para un flujo OpenAPI completo, vea cómo generar datos simulados a partir de esquemas OpenAPI. El estándar JSON Schema permite que tipos, formatos y rangos sean legibles por máquina.

4. Generadores basados en IA

Los generadores con IA producen datos más contextuales: tickets de soporte, descripciones de producto, perfiles de usuario o registros donde varios campos deben tener sentido juntos.

Son útiles cuando necesita coherencia entre campos, por ejemplo:

{
  "plan": "Enterprise",
  "companySize": 1200,
  "supportTicket": "Necesitamos aumentar el límite de rate limiting para nuestra integración interna."
}

Para un ejemplo práctico, consulte generación de datos simulados usando Claude Code.

Cómo generar datos de prueba en Apidog

Si prueba APIs en Apidog, puede generar datos desde el mismo flujo donde diseña, simula y ejecuta pruebas. No necesita mantener un generador separado.

Apidog integra generación de datos en tres puntos clave.

1. Simulación inteligente con reglas de campo

Cuando Apidog simula un endpoint, lee nombres y tipos de campos para devolver valores realistas.

Por ejemplo:

• email devuelve un email válido.
• createdAt devuelve una fecha.
• price devuelve un número.
• status puede limitarse a valores como active, pending o closed.

También puede añadir reglas de estilo Faker por campo para controlar la salida.

Descargue Apidog y defina un endpoint para empezar a recibir datos realistas sin mantener un db.json.

2. Datos de prueba generados por IA

Apidog puede generar lotes de registros de prueba a partir del esquema del endpoint. Esto reduce el trabajo manual cuando necesita varias filas con datos variados.

Úselo para preparar rápidamente:

• Usuarios válidos e inválidos.
• Productos con distintos precios y categorías.
• Pedidos con estados diferentes.
• Payloads para pruebas de validación.

3. Pruebas basadas en datos

En una prueba basada en datos, adjunta un CSV o JSON a un paso de prueba. Apidog ejecuta el mismo paso una vez por fila y sustituye los valores como variables.

Ejemplo de dataset JSON:

[
  {
    "email": "[e-mail]",
    "password": "ValidPass123",
    "expectedStatus": 200
  },
  {
    "email": "invalid-email",
    "password": "ValidPass123",
    "expectedStatus": 400
  },
  {
    "email": "[e-mail]",
    "password": "",
    "expectedStatus": 400
  }
]

Esto permite mantener una sola prueba y ampliar la cobertura agregando filas.

La mecánica se explica en cómo ejecutar pruebas de API parametrizadas desde CSV y JSON. Si está comparando herramientas, vea qué herramienta usar para pruebas de API basadas en datos. Para CI, los mismos datasets funcionan desde terminal con pruebas basadas en datos en la CLI de Apidog.

Paso a paso: generar datos de prueba para un endpoint en Apidog

1. Abra su proyecto en Apidog.
2. Seleccione el endpoint para el que necesita datos.
3. Defina el esquema de respuesta o impórtelo desde OpenAPI.
4. Active la simulación del endpoint.
5. Revise los valores generados automáticamente.
6. Ajuste reglas de campos específicos si necesita controlar valores.
   • Ejemplo: status solo puede ser active, pending o closed.
   • Ejemplo: price debe estar entre 10 y 500.
7. Cree un dataset CSV o JSON para pruebas repetibles.
8. Adjunte el dataset al paso de prueba.
9. Ejecute la prueba y valide cada iteración con aserciones.

Resultado: obtiene respuestas simuladas para desarrollo y datos repetibles para pruebas automatizadas desde el mismo espacio de trabajo.

Cómo elegir un generador de datos de prueba

Si necesita…	Use	Por qué
Control programático completo en JS/Python	Librería Faker	Flexible, programable y reproducible con semillas
Un archivo semilla estático rápido	Mockaroo o similar	Sin código; exportar y usar
Datos alineados con el contrato API	Generador basado en OpenAPI/JSON Schema	Se mantiene sincronizado con la especificación
Registros contextuales y coherentes	Generador con IA	Mejor coherencia entre múltiples campos
Datos conectados a mocks y pruebas	Apidog	Una herramienta para simular, generar y ejecutar pruebas

No hay un único ganador. Si su equipo escribe muchos scripts, Faker puede ser suficiente. Si ya diseña y prueba APIs en Apidog, puede generar datos, simular endpoints y ejecutar pruebas basadas en datos sin salir del workspace.

Mejores prácticas para datos de prueba de API

• Use semillas cuando necesite reproducibilidad. Si una prueba falla, debe poder regenerar el mismo dataset.
• Incluya datos inválidos. Campos vacíos, tipos incorrectos, payloads grandes, fechas caducadas y tokens inválidos también deben probarse.
• Mantenga datos y esquema sincronizados. Si cambia el contrato, regenere los datos.
• No use PII real. Los datos sintéticos evitan riesgos de privacidad y fugas en repositorios.
• Ajuste el volumen al objetivo. Paginación y rendimiento necesitan miles de filas; validaciones simples pueden necesitar solo algunas.
• Separe casos válidos e inválidos. Facilita leer fallos y mantener aserciones claras.
• Automatice la ejecución. Integre datasets en CI para detectar regresiones con entradas variadas.

Preguntas frecuentes

¿Cuál es la diferencia entre un generador de datos de prueba y un mock server?

Un generador produce datos. Un mock server sirve esos datos mediante HTTP como respuestas falsas de API.

Normalmente necesita ambos: datos realistas y un endpoint que los devuelva. Apidog combina ambos flujos: la simulación devuelve datos generados. Un generador independiente solo entrega archivos.

¿Puedo generar datos de prueba desde mi especificación OpenAPI?

Sí. Las herramientas basadas en esquemas leen tipos, formatos y restricciones de la especificación para crear registros compatibles. Consulte generación de datos simulados a partir de esquemas OpenAPI.

¿Es seguro subir datos de prueba generados a un repositorio?

Sí, siempre que sean sintéticos y no contengan información personal real. Nunca suba exportaciones de producción ni datos de clientes.

¿Cómo ejecuto una prueba con muchas entradas generadas?

Use pruebas basadas en datos. Adjunte un CSV o JSON al paso de prueba y la prueba iterará por cada fila. La guía de pruebas parametrizadas muestra la configuración.

¿Necesito levantar un servidor falso para usar datos de prueba?

No siempre. Si necesita una API REST desechable respaldada por un archivo plano, vea la guía sobre json-server y JSONPlaceholder. Para simulaciones basadas en esquema y compartibles con el equipo, use la simulación incorporada de Apidog.

La versión corta

Un generador de datos de prueba convierte la creación manual de registros en reglas reutilizables. Use una librería como Faker si necesita control desde código, un generador basado en esquemas si quiere alinearse con OpenAPI/JSON Schema, o IA si necesita registros contextuales.

Si ya prueba APIs en Apidog, puede generar datos, simular respuestas y ejecutar pruebas basadas en datos en un solo lugar. Descargue Apidog, apúntelo a un endpoint y empiece a probar con datos realistas desde la primera solicitud.