Convertissez des classes Python en JSON !

Collez du code Python (Pydantic·dataclass) et obtenez un JSON d'exemple ! Compatible avec Pydantic BaseModel, Field(alias), dataclass, TypedDict. Pratique pour documenter une API et créer des corps de requête de test (mock request body).
Python
Résultat
 

Convertissez des classes Python en JSON !

Collez des modèles Python écrits avec BaseModel de Pydantic, @dataclass ou TypedDict, et récupérez un document JSON d'exemple qui suit leur structure. Field(alias=...) et une config alias_generator=to_camel sont lus : vous voyez les clés vers lesquelles vos champs snake_case sont réellement sérialisés.

Adapté à la construction d'exemples de requêtes pour des endpoints FastAPI, au partage du schéma d'un payload de webhook ou de file avec une autre équipe, ou à la préparation de fixtures JSON pour pytest.

Mode d'emploi

  1. Collez le contenu du fichier .py qui contient vos modèles. Les lignes import, les méthodes et les décorateurs comme @field_validator sont ignorés.
  2. Incluez les sous-modèles référencés et les classes Enum pour que ces parties soient remplies. Les références anticipées sous forme de chaîne ("Order") sont comprises.
  3. Sur Automatique, Type racine choisit la classe qui n'est utilisée comme type de champ par aucun autre modèle ; vous pouvez aussi en choisir une dans la liste.
  4. Copiez le JSON dans les examples de json_schema_extra, un fichier de données de test ou votre doc d'API.

Exemple

Entrée (Python · Pydantic)
class Payer(BaseModel):
    model_config = ConfigDict(alias_generator=to_camel)
    customer_id: str
    email_address: str

class PaymentEvent(BaseModel):
    model_config = ConfigDict(alias_generator=to_camel)
    event_type: Literal["payment.succeeded", "payment.failed"]
    amount: Decimal
    currency: str = "KRW"
    payer: Payer
    receipt_url: Optional[str] = None
    retry_count: int = Field(default=0, alias="retries")
    raw_payload: dict = Field(exclude=True)
Sortie (JSON)
{
  "eventType": "payment.succeeded",
  "amount": "0",
  "currency": "KRW",
  "payer": {
    "customerId": "",
    "emailAddress": ""
  },
  "receiptUrl": "",
  "retries": 0
}

À cause de to_camel dans model_config, event_type, receipt_url et customer_id deviennent des clés camelCase, tandis que l'alias="retries" explicite l'emporte pour retry_count. raw_payload a Field(exclude=True) et est omis. Le Literal prend sa première valeur, payment.succeeded, et la valeur par défaut littérale "KRW" est conservée telle quelle.

Fonctionnalités prises en charge

  • Lit BaseModel de Pydantic (v1 et v2), @dataclass, TypedDict et Enum/StrEnum/IntEnum, y compris auto().
  • Noms de clés issus de Field(alias=...), de serialization_alias et d'alias_generator (to_camel, to_pascal) défini dans model_config = ConfigDict(...) ou une class Config: interne.
  • Exclus : les noms commençant par _, ClassVar, model_config et les champs Field(exclude=True).
  • Traitement des types : Optional[X] / X | None → exemple de X, Literal[...] → première valeur, Annotated/Required/NotRequired → type interne, list/set/tuple → tableau d'un élément, dict[str, V] → {"key": V}.
  • Types Pydantic : EmailStr, HttpUrl, SecretStr, constr → chaîne ; conint, PositiveInt → 0 ; Decimal et condecimal → la chaîne "0", comme les écrit le JSON de Pydantic v2.
  • Dates et heures : datetime → 1970-01-01T00:00:00, date → 1970-01-01, time → 00:00:00, timedelta → PT0S ; UUID reçoit une valeur bien formée.
  • Les valeurs par défaut littérales chaîne, nombre et True/False servent d'exemples ; une valeur par défaut d'enum comme Status.PAID devient la valeur de ce membre.

Cas d'utilisation

Exemples de requêtes FastAPI

Générez du JSON à partir d'un modèle de requête et placez-le dans model_config = {"json_schema_extra": {"examples": [...]}} ; l'exemple de /docs utilise alors les mêmes clés d'alias que celles attendues par l'endpoint.

Partager des payloads de webhooks et d'événements

Si des payloads de tâches Celery ou de messages Kafka sont définis en Pydantic, donnez aux équipes consommatrices en Node ou en Go le JSON obtenu plutôt que du code Python pour vous accorder sur la structure.

Préparer des fixtures pytest

Créez le squelette d'un fichier JSON pour model_validate_json() ou des tests de client d'API, puis modifiez des valeurs une à une pour ajouter des cas limites.

Remarques et limites

  • Les champs Optional et ceux qui valent None par défaut reçoivent quand même un exemple typé plutôt que null.
  • Decimal est rempli avec la chaîne "0", conformément à la sérialisation JSON de Pydantic v2 (model_dump_json). Si votre projet émet plutôt des nombres (Pydantic v1, ou json.dumps(default=float)), changez-le en nombre.
  • Le code qui remanie la sortie, comme @computed_field, @field_serializer ou @model_serializer, n'est pas exécuté.
  • Union[A, B] utilise le premier membre non None ; les unions discriminées sélectionnées par un champ discriminator ne sont pas modélisées.
  • default_factory et les valeurs par défaut produites par des appels de fonction ne sont pas exécutés ; la valeur vient du type.

FAQ

La sortie utilise les clés d'alias, mais mon model_dump_json() affiche les noms de champs.

Pydantic sérialise par nom de champ sauf si vous passez by_alias=True. Le response_model de FastAPI utilise by_alias=True par défaut, ce qui correspond à la sortie de cet outil. Quand vous faites le dump vous-même, appelez model_dump_json(by_alias=True).

Les dataclasses n'ont pas d'alias. Les clés peuvent-elles quand même différer des noms de champs ?

La dataclass standard n'a pas de renommage : le nom du champ est la clé. Si un champ porte un commentaire final # JSON: "orderId", comme dans les dataclasses produites par la page JSON → Python de ce site, c'est ce nom qui est utilisé.

Les clés NotRequired d'un TypedDict sont-elles incluses ?

Oui. L'exemple vise à montrer toutes les clés possibles : les champs NotRequired et total=False sont donc inclus. Signalez dans votre doc ceux qui peuvent être omis.

Gère-t-il les modèles SQLAlchemy ?

Cette page est destinée aux modèles basés sur les annotations de type. Pour des modèles SQLAlchemy déclarés avec Column(...) ou Mapped[...], utilisez la page SQLAlchemy → JSON.