JSON Templates for Developers — Ready-to-Use Examples for APIs, Config & DevOps

¿Por qué usar plantillas JSON?

Cada desarrollador ha escrito las mismas estructuras JSON docenas de veces: un sobre de respuesta de API, un tsconfig.json, un archivo de Docker Compose. Cada vez, copias de un proyecto anterior (esperando que sea correcto) o escribes desde cero (introduciendo errores sutiles).

Las plantillas eliminan ese ciclo. Comenzar con una estructura probada te brinda cuatro ventajas concretas:

• Ahorra tiempo. Evita el problema del archivo en blanco. Una plantilla te lleva más rápido a la parte interesante de tu trabajo.
• Asegura consistencia. Cuando cada servicio en tu organización devuelve el mismo sobre de API, los consumidores pueden escribir un manejador de respuesta en lugar de diez.
• Reduce errores. Olvidar un campo requerido en un manifiesto de Kubernetes puede derribar un despliegue. Las plantillas incluyen los campos que de otro modo olvidarías.
• Incorporación más rápida. Los nuevos miembros del equipo pueden leer una plantilla y entender inmediatamente la estructura esperada en lugar de tener que desentrañarla a partir de datos de producción.

Las plantillas a continuación cubren las estructuras JSON más comunes en el desarrollo moderno. Cada una está disponible en nuestra Biblioteca de Plantillas donde puedes copiarlas con un solo clic.

Plantillas de Respuesta de API

La plantilla JSON más impactante que puedes adoptar es un sobre de respuesta de API consistente. En lugar de que cada punto final devuelva formas ad-hoc, define un envoltorio estándar con data en caso de éxito, error en caso de falla, y meta para el seguimiento de solicitudes y paginación.

Respuesta de API Paginada

Aquí hay una respuesta paginada del mundo real siguiendo el patrón de sobre:

{
  "data": [
    { "id": "usr_abc123", "name": "Alice Johnson", "role": "admin" },
    { "id": "usr_def456", "name": "Bob Smith", "role": "member" }
  ],
  "meta": {
    "total": 84,
    "page": 2,
    "per_page": 20,
    "total_pages": 5,
    "request_id": "req_9f3b7a"
  }
}

Esta estructura permite a los clientes renderizar controles de paginación desde meta sin adivinar. El request_id hace que la depuración de tickets de soporte sea trivial: solo busca en tus registros.

Explora las plantillas completas: Respuesta de Éxito de API REST, Respuesta de Error de API REST, Respuesta Paginada.

Plantillas de Archivos de Configuración

Los archivos de configuración son donde la mayoría de los errores JSON ocurren en silencio. Una opción de compilador incorrecta en tsconfig.json no falla — solo produce una salida sutilmente incorrecta. Comenzar desde una plantilla verificada evita eso.

Configuración de TypeScript

Un tsconfig.json mínimo pero listo para producción para un proyecto de Next.js:

{
  "compilerOptions": {
    "target": "ES2017",
    "lib": ["dom", "dom.iterable", "esnext"],
    "module": "esnext",
    "moduleResolution": "bundler",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "jsx": "preserve",
    "paths": { "@/*": ["./src/*"] }
  },
  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
  "exclude": ["node_modules"]
}

Las elecciones clave aquí: strict: true captura errores de tipo temprano, moduleResolution: "bundler" se alinea con los empaquetadores modernos, y el alias de ruta @/* mantiene las importaciones limpias.

Plantillas de configuración: package.json, tsconfig.json, Configuración de ESLint.

Plantillas de Esquema de Base de Datos

Ya sea que estés sembrando una base de datos de desarrollo o definiendo una estructura de documento para MongoDB, tener una plantilla significa que tu equipo acuerda nombres de campos, tipos y valores predeterminados antes de la primera línea de código de aplicación.

Documento de Usuario de MongoDB

{
  "_id": "ObjectId('66a1b2c3d4e5f6a7b8c9d0e1')",
  "email": "alice@example.com",
  "profile": {
    "firstName": "Alice",
    "lastName": "Johnson",
    "avatar": "https://cdn.example.com/avatars/alice.jpg"
  },
  "roles": ["admin", "editor"],
  "settings": { "theme": "dark", "locale": "en-US" },
  "createdAt": "2026-01-15T09:30:00Z",
  "updatedAt": "2026-03-20T14:22:00Z"
}

Esta estructura anida campos relacionados bajo profile y settings para mantener el documento de nivel superior lo suficientemente plano para un indexado eficiente mientras agrupa datos lógicamente relacionados.

Plantillas de base de datos: Esquema de MongoDB, Datos de Siembra de Prisma.

Plantillas de DevOps y Nube

Los archivos de infraestructura como código son algunos de los JSON más propensos a errores que escribirás. Un campo faltante en un manifiesto de Kubernetes o una plantilla de CloudFormation puede causar fallos silenciosos que solo aparecen en producción. Las plantillas te dan un punto de partida conocido y bueno.

Despliegue de Kubernetes

Un manifiesto de despliegue de Kubernetes simplificado en formato JSON:

{
  "apiVersion": "apps/v1",
  "kind": "Deployment",
  "metadata": {
    "name": "web-api",
    "labels": { "app": "web-api", "env": "production" }
  },
  "spec": {
    "replicas": 3,
    "selector": { "matchLabels": { "app": "web-api" } },
    "template": {
      "metadata": { "labels": { "app": "web-api" } },
      "spec": {
        "containers": [{
          "name": "web-api",
          "image": "registry.example.com/web-api:1.4.2",
          "ports": [{ "containerPort": 8080 }],
          "resources": {
            "requests": { "cpu": "250m", "memory": "256Mi" },
            "limits": { "cpu": "500m", "memory": "512Mi" }
          }
        }]
      }
    }
  }
}

Las solicitudes y límites de recursos se incluyen por defecto: omitirlos es la causa número uno de problemas de vecinos ruidosos en clústeres compartidos. Las etiquetas siguen la convención estándar app / env para que los selectores y políticas de red funcionen sin problemas.

Plantillas de infraestructura: Docker Compose, Despliegue de Kubernetes, Flujo de Trabajo de GitHub Actions.

Plantilla de Carga Útil JWT

Los JSON Web Tokens llevan reclamaciones como una carga útil JSON. Obtener las reclamaciones estándar correctas es crítico: una reclamación exp faltante significa que los tokens nunca expiran, y un iss incorrecto rompe la verificación.

{
  "sub": "usr_abc123",
  "iss": "https://auth.example.com",
  "aud": "https://api.example.com",
  "exp": 1774648800,
  "iat": 1774645200,
  "nbf": 1774645200,
  "roles": ["admin", "editor"],
  "email": "alice@example.com"
}

Las reclamaciones registradas (sub, iss, aud, exp, iat, nbf) siguen RFC 7519. Las reclamaciones personalizadas como roles y email deben usar nombres cortos para mantener el tamaño del token pequeño: los JWT viajan en encabezados HTTP donde cada byte cuenta.

Consulta la plantilla completa: Carga Útil JWT.

Cómo Personalizar Plantillas

Una plantilla es un punto de partida, no un producto terminado. Aquí hay un flujo de trabajo práctico para adaptar cualquier plantilla a tu proyecto:

• Comienza desde la plantilla más cercana. Elige la que más se asemeje a tu caso de uso. Una plantilla de respuesta paginada es un mejor punto de partida para un punto final de búsqueda que una respuesta de éxito genérica.
• Renombra y añade campos. Cambia los valores de marcador de posición por tus nombres de campo reales. Añade campos específicos de dominio que tu aplicación necesite. Elimina campos que no apliquen.
• Valida el resultado. Pega tu JSON modificado en nuestro Validador JSON para detectar errores de sintaxis: una coma final o una comilla faltante es fácil de introducir al editar a mano.
• Formatea para legibilidad. Pásalo por el Formateador JSON para asegurar una indentación consistente antes de comprometerlo a tu base de código o compartirlo con tu equipo.
• Asegúralo con un esquema. Para estructuras críticas como respuestas de API, define un Esquema JSON para que los cambios futuros se validen automáticamente.

Explora Todas las Plantillas

Los ejemplos en esta guía son solo una muestra. Nuestra Biblioteca de Plantillas incluye 18 plantillas listas para usar que cubren APIs, configuración, bases de datos, autenticación e infraestructura en la nube, cada una con explicaciones campo por campo y soporte para copiar al portapapeles.

Explora la colección completa: Visita la Biblioteca de Plantillas JSON para encontrar plantillas para tu stack. Copia cualquier plantilla con un clic, personalízala y valida el resultado con nuestro Formateador JSON.