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

Warum JSON-Vorlagen verwenden?

Jeder Entwickler hat die gleichen JSON-Strukturen dutzende Male geschrieben — ein API-Antwortumschlag, eine tsconfig.json, eine Docker-Compose-Datei. Jedes Mal kopierst du entweder aus einem vorherigen Projekt (in der Hoffnung, dass es korrekt war) oder schreibst von Grund auf neu (was subtile Fehler einführt).

Vorlagen beseitigen diesen Zyklus. Der Start mit einer bewährten Struktur bietet dir vier konkrete Vorteile:

• Zeit sparen. Überspringe das Problem mit der leeren Datei. Eine Vorlage bringt dich schneller zum interessanten Teil deiner Arbeit.
• Konsistenz sicherstellen. Wenn jeder Dienst in deiner Organisation denselben API-Umschlag zurückgibt, können Verbraucher einen Antwort-Handler anstelle von zehn schreiben.
• Fehler reduzieren. Das Vergessen eines erforderlichen Feldes in einem Kubernetes-Manifest kann ein Deployment zum Absturz bringen. Vorlagen enthalten die Felder, die du sonst vergessen würdest.
• Schneller einarbeiten. Neue Teammitglieder können eine Vorlage lesen und sofort die erwartete Struktur verstehen, anstatt sie aus Produktionsdaten rückzuentwickeln.

Die untenstehenden Vorlagen decken die häufigsten JSON-Strukturen in der modernen Entwicklung ab. Jede von ihnen ist in unserer Vorlagenbibliothek verfügbar, wo du sie mit einem Klick kopieren kannst.

API-Antwortvorlagen

Die wirkungsvollste JSON-Vorlage, die du übernehmen kannst, ist ein konsistenter API-Antwortumschlag. Anstatt dass jeder Endpunkt ad-hoc Formen zurückgibt, definiere einen Standardwrapper mit data bei Erfolg, error bei Fehlern und meta für die Anforderungsverfolgung und Paginierung.

Paginierte API-Antwort

Hier ist eine reale paginierte Antwort, die dem Umschlagmuster folgt:

{
  "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"
  }
}

Diese Struktur ermöglicht es den Clients, Paginierungssteuerungen aus meta zu rendern, ohne raten zu müssen. Die request_id macht das Debuggen von Support-Tickets trivial — suche einfach in deinen Protokollen.

Durchsuche die vollständigen Vorlagen: REST API Erfolgsantwort, REST API Fehlerantwort, Paginierte Antwort.

Vorlagen für Konfigurationsdateien

Konfigurationsdateien sind der Ort, an dem die meisten JSON-Fehler stillschweigend auftreten. Eine falsche Compiler-Option in tsconfig.json führt nicht zum Absturz — sie produziert einfach subtil falsche Ausgaben. Der Start mit einer geprüften Vorlage vermeidet das.

TypeScript-Konfiguration

Eine minimale, aber produktionsbereite tsconfig.json für ein Next.js-Projekt:

{
  "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"]
}

Die wichtigsten Entscheidungen hier: strict: true fängt Typfehler frühzeitig ab, moduleResolution: "bundler" stimmt mit modernen Bundlern überein, und der @/*-Pfadalias hält die Importe sauber.

Konfigurationsvorlagen: package.json, tsconfig.json, ESLint-Konfiguration.

Vorlagen für Datenbankschemata

Ob du eine Entwicklungsdatenbank seedest oder eine Dokumentstruktur für MongoDB definierst, eine Vorlage bedeutet, dass dein Team sich vor der ersten Zeile Anwendungs-Code auf Feldnamen, Typen und Standardwerte einigt.

MongoDB-Benutzerdokument

{
  "_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": "de-DE" },
  "createdAt": "2026-01-15T09:30:00Z",
  "updatedAt": "2026-03-20T14:22:00Z"
}

Diese Struktur nestet verwandte Felder unter profile und settings, um das oberste Dokument flach genug für effizientes Indizieren zu halten, während logisch verwandte Daten gruppiert werden.

Datenbankvorlagen: MongoDB-Schema, Prisma Seed-Daten.

DevOps- und Cloud-Vorlagen

Infrastructure-as-Code-Dateien sind einige der fehleranfälligsten JSONs, die du schreiben wirst. Ein fehlendes Feld in einem Kubernetes-Manifest oder einer CloudFormation-Vorlage kann stille Fehler verursachen, die nur in der Produktion sichtbar werden. Vorlagen geben dir einen bekannten, funktionierenden Ausgangspunkt.

Kubernetes-Deployment

Ein vereinfachtes Kubernetes-Deployment-Manifest im JSON-Format:

{
  "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" }
          }
        }]
      }
    }
  }
}

Ressourcenanforderungen und -limits sind standardmäßig enthalten — sie zu überspringen ist die häufigste Ursache für Probleme mit lauten Nachbarn in gemeinsamen Clustern. Die Labels folgen der Standardkonvention app / env, sodass Selektoren und Netzwerkrichtlinien sofort funktionieren.

Infrastrukturvorlagen: Docker Compose, Kubernetes-Deployment, GitHub Actions-Workflow.

JWT-Nutzlastvorlage

JSON Web Tokens tragen Ansprüche als JSON-Nutzlast. Die korrekte Handhabung der Standardansprüche ist entscheidend — ein fehlender exp-Anspruch bedeutet, dass Tokens niemals ablaufen, und ein falscher iss-Anspruch bricht die Überprüfung.

{
  "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"
}

Die registrierten Ansprüche (sub, iss, aud, exp, iat, nbf) folgen RFC 7519. Benutzerdefinierte Ansprüche wie roles und email sollten kurze Namen verwenden, um die Token-Größe klein zu halten — JWTs reisen in HTTP-Headern, wo jedes Byte zählt.

Siehe die vollständige Vorlage: JWT-Nutzlast.

So passt du Vorlagen an

Eine Vorlage ist ein Ausgangspunkt, kein fertiges Produkt. Hier ist ein praktischer Workflow, um jede Vorlage an dein Projekt anzupassen:

• Beginne mit der nächsten Vorlage. Wähle diejenige aus, die deinem Anwendungsfall am nächsten kommt. Eine Vorlage für paginierte Antworten ist ein besserer Ausgangspunkt für einen Suchendpunkt als eine allgemeine Erfolgsantwort.
• Benennen und Felder hinzufügen. Ändere Platzhalterwerte in deine tatsächlichen Feldnamen. Füge domänenspezifische Felder hinzu, die deine Anwendung benötigt. Entferne Felder, die nicht zutreffen.
• Das Ergebnis validieren. Füge dein modifiziertes JSON in unseren JSON-Validator ein, um Syntaxfehler zu erkennen — ein überflüssiges Komma oder ein fehlendes Anführungszeichen ist leicht einzuführen, wenn man von Hand bearbeitet.
• Für Lesbarkeit formatieren. Lass es durch den JSON-Formatter laufen, um eine konsistente Einrückung sicherzustellen, bevor du es in dein Code-Repository einfügst oder mit deinem Team teilst.
• Mit einem Schema absichern. Für kritische Strukturen wie API-Antworten definiere ein JSON-Schema, damit zukünftige Änderungen automatisch validiert werden.

Durchsuche alle Vorlagen

Die Beispiele in diesem Leitfaden sind nur eine Auswahl. Unsere Vorlagenbibliothek umfasst 18 einsatzbereite Vorlagen für APIs, Konfiguration, Datenbanken, Authentifizierung und Cloud-Infrastruktur — jede mit Feld-für-Feld-Erklärungen und Unterstützung zum Kopieren in die Zwischenablage.

Durchsuche die gesamte Sammlung: Besuche die JSON-Vorlagenbibliothek, um Vorlagen für deinen Stack zu finden. Kopiere jede Vorlage mit einem Klick, passe sie an und validiere das Ergebnis mit unserem JSON-Formatter.