ForHosting KIT · Outils pour développeurs

Générez une interface TypeScript depuis JSON

Collez un objet d’exemple et obtenez une interface TypeScript prête : dans l’exemple, id devient number, tags devient string[] et la clé display-name reste entre guillemets, le tout sous le nom UserRecord. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

L’outil analyse l’exemple, vérifie que sa racine est un objet et produit une interface déterministe pour les chaînes, nombres, booléens, valeurs nulles, tableaux et objets imbriqués.

Comment chaque type est déduit

Le générateur regarde chaque valeur de votre exemple, pas le nom des clés. Un texte devient string, tout nombre devient number, vrai ou faux reçoit son propre type oui-non, et une valeur vide devient null. Les objets contenus dans d’autres objets deviennent des types imbriqués, et les listes sont jugées sur tous leurs éléments, pas seulement le premier : une liste de textes donne string[], une liste mélangée une union comme (string | number | null)[]. Les clés impossibles à écrire telles quelles, comme display-name, restent entre guillemets, et les propriétés gardent l’ordre de l’exemple d’origine.

Erreurs courantes et comment les éviter

Un seul exemple ne peut pas prouver qu’une donnée est facultative : toutes les propriétés sont donc marquées comme obligatoires, à vous d’ajuster à la main là où vos vraies données peuvent omettre quelque chose. Une liste vide n’apporte aucun indice et devient unknown[], un objet vide devient Record<string, never> ; choisissez donc un exemple dont les listes et les objets sont remplis. Le texte doit suivre un format de données strict, pas du JavaScript : noms entre guillemets doubles, ni commentaires ni virgules finales, et un objet au niveau supérieur. Dates, valeurs fixes et énumérations ne sont jamais inventées.

Partez d’un exemple fidèle à vos données réelles

Les objets imbriqués sont représentés par des types d’objet dans l’interface racine. Chaque propriété observée est rendue obligatoire, car un seul exemple ne peut pas prouver qu’un champ est facultatif. Pour obtenir un résultat utile, choisissez un exemple contenant les champs et variantes réellement reçus par votre application.

Vous pouvez aussi fournir un nom racine comme <code>UserResponse</code> ; il doit être un identifiant TypeScript valide et non réservé. À défaut, <code>RootObject</code> est utilisé. Une racine scalaire, nulle ou sous forme de tableau est refusée.

Comprenez les tableaux, valeurs nulles et structures imbriquées

L’inférence d’un tableau examine tous les éléments de l’exemple, et pas uniquement le premier. Une liste de chaînes devient <code>string[]</code>, tandis qu’une liste mixte produit une union stable telle que <code>(string | number | null)[]</code>. Un tableau vide ne donne aucune indication sur ses éléments : il devient donc <code>unknown[]</code> plutôt que de recevoir un type arbitraire.

Les objets placés dans des tableaux sont exprimés sous forme de types d’objet en ligne, et les tableaux imbriqués sont traités récursivement. Les objets vides deviennent <code>Record<string, never></code>, ce qui signale qu’aucun champ connu n’a été observé. Les clés incompatibles avec un identifiant TypeScript ordinaire, notamment celles contenant des espaces, signes ou mots réservés, sont placées entre guillemets.

Le générateur n’invente ni propriétés facultatives, ni dates, ni littéraux, ni énumérations, ni noms de classes propres au domaine.

Questions fréquentes

Quelles entrées sont acceptées ?

Les tableaux, scalaires et valeurs nulles à la racine sont refusés.

Comment les tableaux vides sont-ils typés ?

Ils deviennent unknown[], car un exemple vide ne fournit aucune indication sur le type de ses éléments.

Les propriétés sont-elles facultatives ?

Non. Les propriétés présentes sont obligatoires. Consultez plusieurs charges ou un schéma officiel pour repérer les champs facultatifs.

Puis-je choisir le nom de l’interface ?

Oui. Saisissez un nom comme UserRecord ; il doit s’agir d’un nom TypeScript valide qui ne soit pas un mot réservé. Si vous le laissez vide, l’interface s’appelle RootObject, et chaque nouvel essai donne exactement le même texte.

Quel type reçoit une liste aux valeurs mélangées ?

Tous les éléments sont examinés, pas seulement le premier. Une liste composée uniquement de textes donne string[], tandis qu’un mélange produit une union stable comme (string | number | null)[] : le résultat reflète exactement ce que montre l’exemple.

Outils associés

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

POSThttps://api.kit.forhosting.com/dev2/json-to-typescript-interface

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre stack

curl -X POST https://api.kit.forhosting.com/dev2/json-to-typescript-interface \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"json":"{\"id\":42,\"name\":\"Ada\",\"active\":true,\"tags\":[\"admin\",\"editor\"],\"profile\":{\"email\":\"ada@example.com\",\"score\":9.5}}"}'

const res = await fetch("https://api.kit.forhosting.com/dev2/json-to-typescript-interface", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "json": "{\"id\":42,\"name\":\"Ada\",\"active\":true,\"tags\":[\"admin\",\"editor\"],\"profile\":{\"email\":\"ada@example.com\",\"score\":9.5}}"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev2/json-to-typescript-interface",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "json": "{\"id\":42,\"name\":\"Ada\",\"active\":true,\"tags\":[\"admin\",\"editor\"],\"profile\":{\"email\":\"ada@example.com\",\"score\":9.5}}"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev2/json-to-typescript-interface", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"json":"{\\"id\\":42,\\"name\\":\\"Ada\\",\\"active\\":true,\\"tags\\":[\\"admin\\",\\"editor\\"],\\"profile\\":{\\"email\\":\\"ada@example.com\\",\\"score\\":9.5}}"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"json":"{\"id\":42,\"name\":\"Ada\",\"active\":true,\"tags\":[\"admin\",\"editor\"],\"profile\":{\"email\":\"ada@example.com\",\"score\":9.5}}"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev2/json-to-typescript-interface", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Exemple de requête

{
  "json": "{\"id\":42,\"name\":\"Ada\",\"active\":true,\"tags\":[\"admin\",\"editor\"],\"profile\":{\"email\":\"ada@example.com\",\"score\":9.5}}"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev2.json_to_typescript_interface",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Limites

`max_chars`	1000000
`max_depth`	64

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Notes techniques

Transformez un objet JSON représentatif en interface TypeScript sans installer de générateur ni suivre manuellement chaque valeur imbriquée. Il protège aussi les clés JSON inhabituelles avec des guillemets et vous permet de choisir le nom de l’interface racine. Le résultat peut être copié dans une application, un SDK, un jeu de test ou une intégration de données comme type initial pratique.

Commencez par un objet JSON représentatif

Collez un JSON valide dont la valeur racine est un objet, par exemple une réponse d’API, un enregistrement de configuration, une charge de webhook ou un document stocké. Le générateur examine les valeurs plutôt que les noms de champs : une chaîne devient <code>string</code>, tout nombre JSON devient <code>number</code>, un booléen devient <code>boolean</code> et une valeur nulle devient <code>null</code>. L’entrée doit être du texte JSON, pas une syntaxe d’objet JavaScript : les noms exigent des guillemets doubles, les commentaires sont interdits et les virgules finales invalides.

Comprenez les tableaux, valeurs nulles et structures imbriquées

La sortie reste ainsi fidèle aux éléments observés dans le JSON fourni. L’ordre des propriétés suit le JSON d’origine, tandis que les membres d’une union suivent un ordre déterministe.

Contrôlez l’interface produite avant la mise en production

Comparez-la à plusieurs charges ou à la documentation du fournisseur avant de rendre des propriétés facultatives, nullables, plus précises ou partagées par des interfaces nommées. Si un exemple contient null et un autre une chaîne, ajoutez cette connaissance au type maintenu. La sortie déterministe simplifie la revue : la même entrée et le même nom donnent toujours le même texte, sans réseau, modèle, hasard ni date courante. Considérez la définition produite comme une description fidèle de l’exemple et un excellent premier brouillon, non comme la preuve du contrat complet d’une API externe. Un horodatage reste une chaîne car JSON ne possède aucun type date, et un entier reste <code>number</code> car TypeScript ne distingue pas les entiers JSON à l’exécution. Un JSON invalide, un texte absent, un nom incorrect, une imbrication excessive ou une racine non objet renvoie <code>invalid_input</code>. L’exécution par API commence à $0.002 par requête, et le navigateur applique localement la même logique pure.

Cas d'intégration

Typer une réponse d’API inconnue

Créez une première interface pratique depuis une réponse capturée, puis affinez les champs facultatifs avec la documentation.

Documenter les charges de webhooks

Convertissez un événement représentatif en TypeScript lisible que le service destinataire et ses tests peuvent partager.

Amorcer fixtures et intégrations

Générez des types imbriqués stables pour une configuration, des enregistrements importés ou des données de test.

Questions techniques

Les dates ou énumérations sont-elles reconnues ?

Non. Les chaînes JSON restent des string et aucune sémantique métier ni contrainte enum n’est déduite d’un seul exemple.

Quel est le prix d’une requête API ?

Une requête API commence à $0.002. L’exécuteur du navigateur emploie la même logique déterministe.

Consulter la documentation complète du KIT →

Lancer gratuitement

Comment chaque type est déduit

Erreurs courantes et comment les éviter

Partez d’un exemple fidèle à vos données réelles

Comprenez les tableaux, valeurs nulles et structures imbriquées

Questions fréquentes

Outils associés

Pour les développeurs — accès API

Endpoint

Appeler depuis votre stack

Exemple de requête

Exemple de réponse

Tarifs

Limites

Erreurs

Notes techniques

Commencez par un objet JSON représentatif

Comprenez les tableaux, valeurs nulles et structures imbriquées

Contrôlez l’interface produite avant la mise en production

Cas d'intégration

Typer une réponse d’API inconnue

Documenter les charges de webhooks

Amorcer fixtures et intégrations

Questions techniques

merci