Juan Cruz Viotti

Juan Cruz Viotti est informaticien, auteur chez O’Reilly et membre du comité technique de JSON Schema (TSC), reconnu pour son travail pionnier sur les technologies JSON.
Lauréat de l’Université d’Oxford, il est le créateur de JSON BinPack, une avancée majeure dans la sérialisation efficace en espace, et l’auteur original d’Etcher, un outil open source largement adopté.
En tant que fondateur de Sourcemeta, il mène des travaux de recherche avancée sur JSON, maintient la plateforme Learn JSON Schema, et contribue activement à l’évolution de l’open source et des outils pour développeurs.

• Architectes d’API et Développeurs Backend qui doivent produire des spécifications d’API de haute qualité
• Développeurs Frontend, Ingénieurs DevOps et Ingénieurs QA/Test qui doivent comprendre et consommer les spécifications d’API
• Chefs de produit API, Responsables techniques / Leads, CTO qui ont besoin d’une connaissance approfondie des spécifications d’API pour garantir leur qualité au sein de l’organisation
• Architectes d’entreprise souhaitant assurer l’interopérabilité des composants de leurs systèmes grâce à des spécifications fiables

Connaissances

• Expliquer le rôle et l’importance de JSON Schema dans les spécifications d’API telles qu’OpenAPI et AsyncAPI
• Analyser la qualité des schémas selon les bonnes pratiques et les pièges à éviter
• Décrire le rôle de chaque mot-clé JSON Schema et savoir quand l’utiliser
• Étudier plus en profondeur les spécifications OpenAPI et AsyncAPI en comprenant leur composant central : JSON Schema

Compétences

• Définir des spécifications d’API plus précises et riches en exploitant pleinement les capacités de JSON Schema
• Déboguer des schémas complexes de manière systématique pour identifier les erreurs ou les comportements inattendus
• Concevoir des schémas de haute qualité décrivant avec exactitude tout type de document JSON, quelle qu’en soit la complexité
• Auditer et améliorer des spécifications d’API existantes à partir de leurs définitions JSON Schema

Aptitudes

• Démontrer une maîtrise avancée de JSON Schema pour contribuer à des groupes de travail open source (JSON Schema, OpenAPI, AsyncAPI, W3C Web of Things)
• Collaborer efficacement avec différentes équipes pour garantir le bon usage de JSON Schema
• Développer des outils personnalisés pour JSON Schema, OpenAPI et AsyncAPI afin de résoudre les besoins spécifiques de l’organisation
• Améliorer les guides et linters de conception OpenAPI/AsyncAPI grâce à une compréhension approfondie de JSON Schema

• Compréhension de base du format d’échange de données JSON
• Aucune expertise technique approfondie requise
• Maîtrise de l’anglais écrit et parlé indispensable (cours et évaluations en anglais)

Ce cours se compose de 14 modules.
Chaque module est sanctionné par un test de 10 questions à choix multiple. Le succès de ce test avec un score de 10/10 est obligatoire pour pouvoir passer au module suivant. Le test peut-être recommencé autant de fois que nécessaire et n’est pas délimité dans le temps. Chaque test prend entre 3 et 10 minutes à compléter.

Module 1 :
Durée moyenne : 30 minutes.
Maîtriser JSON Schema pour maîtriser OpenAPI — pourquoi JSON Schema est la clé d’une conception d’API d’excellence

JSON Schema est la norme la plus utilisée pour décrire des données JSON, adoptée par 94 % des développeurs d’API. OpenAPI repose essentiellement sur JSON Schema. Dans des spécifications réelles, comme celles de Stripe, plus de 80 % du contenu correspond à du JSON Schema.

Ce module explique pourquoi maîtriser JSON Schema est la compétence la plus déterminante pour élever son expertise OpenAPI. Il introduit également une bonne pratique essentielle : organiser les schémas dans des fichiers séparés pour assurer leur maintenabilité et leur compatibilité avec les outils.

Résultats d’apprentissage :

Comprendre la relation entre JSON Schema et OpenAPI

Identifier l’adoption de JSON Schema dans le développement d’API

Expliquer en quoi OpenAPI constitue un “wrapper” autour de JSON Schema

Appliquer les bonnes pratiques pour organiser les schémas en fichiers séparés

Connaissances :

Architecture et rôle de JSON Schema dans OpenAPI

Structure d’un schéma JSON et intégration dans une spécification

Principe de séparation des schémas pour la maintenance

Compétences :

Créer et organiser des schémas dans des fichiers dédiés

Maintenir des schémas interopérables et réutilisables

Appliquer les principes de modularité dans les spécifications OpenAPI

Aptitudes :

Concevoir des spécifications OpenAPI robustes fondées sur JSON Schema

Garantir la cohérence et la maintenabilité des schémas dans un écosystème API complexe

Module 2 :
Durée moyenne : 35 minutes.
Décrypter l’architecture de JSON Schema — mots-clés, vocabulaires, dialectes et méta-schémas

La puissance de JSON Schema réside dans son architecture extensible. Ce module explique les quatre blocs fondamentaux qui structurent le langage : les mots-clés (éléments atomiques), les vocabulaires (groupes de mots-clés identifiés par URI), les dialectes (ensembles de vocabulaires) et les méta-schémas (schémas qui valident d’autres schémas). Comprendre cette hiérarchie permet de lire et de concevoir des schémas conformes et évolutifs.

Résultats d’apprentissage :

Définir les quatre éléments de base de l’architecture JSON Schema

Identifier les vocabulaires à partir de leurs URIs dans les méta-schémas

Distinguer dialectes, méta-schémas et sous-schémas

Connaissances :

Fonctionnement hiérarchique du langage JSON Schema

Principe des vocabulaires et du versionnage des dialectes

Notion de récursivité et de sous-schémas

Compétences :

Lire et interpréter la structure d’un schéma complexe

Identifier la version et les dépendances d’un schéma

Construire des schémas compatibles avec un dialecte donné

Aptitudes :

Naviguer entre les versions de JSON Schema

Concevoir des schémas robustes et standardisés dans un environnement multi-outils

Module 3 :
Durée moyenne : 50 minutes.
Une méthode systématique pour lire et comprendre n’importe quel JSON Schema

Il n’est pas nécessaire de mémoriser tous les mots-clés JSON Schema. Ce module enseigne une méthode pas à pas pour analyser et comprendre tout schéma, quel que soit son niveau de complexité. Il couvre la détermination du dialecte, l’identification des vocabulaires, la lecture des dépendances et l’ordre d’évaluation, tout en expliquant pourquoi JSON Schema est un langage de contraintes plutôt qu’un langage de modélisation.

Résultats d’apprentissage :

Appliquer une méthode systématique en quatre étapes pour lire un schéma

Déterminer les dialectes et vocabulaires à partir des déclarations

Suivre l’ordre d’évaluation des mots-clés et leurs interdépendances

Différencier les approches contraintes et modélisation

Utiliser le principe “ai-je interdit tout ce que je ne veux pas ?” dans la conception

Connaissances :

Concepts de dialecte, vocabulaire et ordre d’évaluation

Nature contrainte du langage JSON Schema

Structure logique d’un validateur JSON Schema

Compétences :

Lire un schéma inconnu de manière méthodique

Identifier les zones de conflit ou de redondance

Évaluer les dépendances entre mots-clés

Aptitudes :

Déboguer et comprendre tout schéma, quel qu’en soit le vocabulaire

Concevoir des schémas fiables fondés sur une logique de validation cohérente

Module 4 :
Durée moyenne : 50 minutes.
Maîtriser les chaînes JSON — encodage Unicode, expressions régulières et validation des formats

Les chaînes sont essentielles en JSON, mais leur traitement nécessite de comprendre l’encodage Unicode et les différences entre points de code et octets. Ce module approfondit la validation des chaînes à l’aide de mots-clés tels que minLength, maxLength et pattern, tout en clarifiant les subtilités liées au mot-clé format, souvent mal compris.

Résultats d’apprentissage :

Expliquer la différence entre points de code Unicode et taille en octets

Utiliser minLength, maxLength et pattern pour la validation des chaînes

Créer des expressions régulières conformes à ECMA-262

Choisir entre format (validation sémantique) et pattern (validation syntaxique)

Connaissances :

Encodage UTF-8 et représentation des caractères

Principes de validation des chaînes JSON

Fonctionnement du mot-clé format

Compétences :

Écrire des schémas robustes pour valider les chaînes

Utiliser les expressions régulières pour contrôler les formats

Identifier et éviter les erreurs liées à l’encodage

Aptitudes :

Concevoir des validations précises et cohérentes pour les chaînes JSON

Garantir la compatibilité internationale des données textuelles

Module 5 :
Durée moyenne : 35 minutes.
Maîtriser les nombres JSON — entiers, flottants, précision et interopérabilité

Les nombres JSON sont plus complexes qu’ils n’y paraissent. Ce module explore les limites de précision liées aux parseurs et aux langages de programmation, ainsi que les contraintes définies dans la norme RFC 8259. Il présente l’usage avancé de multipleOf, minimum, maximum et leurs variantes exclusives pour contrôler la précision et la portée des valeurs numériques.

Résultats d’apprentissage :

Identifier les limites d’interopérabilité liées aux nombres flottants en JavaScript

Utiliser multipleOf pour contrôler la précision décimale

Définir les plages de valeurs avec minimum, maximum et variantes exclusives

Contourner les problèmes de précision avec des représentations alternatives

Connaissances :

Représentation et parsing des nombres JSON

Contraintes de validation numériques selon la norme RFC 8259

Différences entre entiers et flottants

Compétences :

Appliquer les contraintes de plage et de divisibilité

Créer des schémas gérant la précision numérique

Adapter les schémas aux limites des langages

Aptitudes :

Assurer la fiabilité et la cohérence des données numériques dans les API

Concevoir des modèles numériques portables et précis

Module 6 :
Durée moyenne : 40 minutes.
Les tableaux dans JSON Schema — validation, contraintes et modèles de tuples

Les tableaux sont des séquences ordonnées d’éléments JSON. Ce module présente les outils de validation disponibles : contraintes de taille (minItems, maxItems), unicité (uniqueItems), assertions de contenu (contains, minContains, maxContains) et différenciation entre tableaux homogènes et tuples hétérogènes.

Résultats d’apprentissage :

Appliquer les contraintes de taille et de contenu sur les tableaux

Différencier les modèles homogènes et hétérogènes

Combiner prefixItems et items pour créer des schémas expressifs

Connaissances :

Structure et sémantique des tableaux JSON

Utilisation des opérateurs contains et uniqueItems

Modélisation des tuples avec prefixItems

Compétences :

Construire des schémas de tableaux précis et flexibles

Définir des règles de composition et de validation complexes

Aptitudes :

Concevoir des validations robustes pour tout type de tableau

Gérer la composition de structures complexes et imbriquées

Module 7 :

Durée moyenne : 75 minutes.
Les objets dans JSON Schema — propriétés, modèles et composition avancée

Les objets sont les structures centrales de JSON. Ce module détaille les opérateurs dédiés : properties, patternProperties, additionalProperties, minProperties, required, propertyNames et dependentSchemas. Il montre comment combiner ces mécanismes pour créer des schémas précis et maintenables.

Résultats d’apprentissage :

Appliquer la validation des propriétés et des tailles d’objet

Créer des dépendances conditionnelles entre propriétés

Valider les noms de propriété et les propriétés additionnelles

Connaissances :

Règles de validation des objets JSON

Fonctionnement des mots-clés de dépendance et de taille

Interaction entre propriétés et schémas additionnels

Compétences :

Définir des objets complexes et hiérarchiques

Gérer les relations entre champs dépendants

Créer des validations dynamiques par propriété

Aptitudes :

Concevoir des objets API précis et cohérents

Gérer la complexité des dépendances dans les modèles JSON

Module 8 :
Durée moyenne : 40 minutes.
Description : Opérateurs logiques — logique conditionnelle et validation avancée

Ce module aborde les opérateurs logiques de JSON Schema, essentiels pour créer des validations conditionnelles : anyOf, oneOf, allOf, not et if-then-else. Il enseigne quand et comment les utiliser, tout en évitant la complexité inutile.

Résultats d’apprentissage :

Choisir les opérateurs logiques appropriés selon les besoins de validation

Appliquer la validation conditionnelle avec if-then-else

Simplifier la logique à l’aide de la conception orientée contraintes

Connaissances :

Principes logiques de disjonction, conjonction et négation

Interaction entre opérateurs logiques et structure de schéma

Compétences :

Construire des schémas conditionnels

Combiner les opérateurs pour des validations complexes

Aptitudes :

Concevoir des règles de validation expressives et maintenables

Simplifier des schémas complexes grâce à la logique JSON Schema

Module 9 :
Durée moyenne : 70 minutes.
Démystifier les références et les ressources — maîtriser la composition et le partage des schémas

Le système de références de JSON Schema est extrêmement puissant, car il permet de composer des schémas modulaires et réutilisables. Cependant, c’est aussi l’un des sujets les plus complexes à maîtriser. Ce module clarifie en détail le fonctionnement des références et des ressources, en expliquant les fondements des URI (RFC 3986), l’usage des mots-clés $id, $defs et $ref, ainsi que les mécanismes d’ancrage ($anchor) et de déploiement des schémas (bundling et dé-référencement).

Résultats d’apprentissage :

Appliquer les règles de résolution des URI selon la norme RFC 3986

Créer des ressources de schéma identifiées par $id

Organiser des sous-schémas réutilisables avec $defs

Gérer les références internes et externes à l’aide de $ref et des pointeurs JSON

Utiliser $anchor pour des références indépendantes de la position

Mettre en œuvre le bundling et le dé-référencement pour distribuer les schémas

Connaissances :

Structure et rôle des URI et des pointeurs JSON

Fonctionnement des références statiques et dynamiques

Principes du bundling et de la modularisation des schémas

Compétences :

Créer et relier des schémas interconnectés

Maintenir des bibliothèques de schémas réutilisables

Gérer la distribution et l’intégration des schémas au sein d’organisations

Aptitudes :

Développer une architecture de schémas évolutive et collaborative

Assurer la cohérence et la traçabilité des références dans les API complexes

Module 10 :
Durée moyenne : 45 minutes.
Les applicateurs dynamiques avancés — unevaluatedProperties et unevaluatedItems

Le vocabulaire Unevaluated introduit deux applicateurs puissants : unevaluatedProperties et unevaluatedItems. Ces mots-clés permettent de contrôler la validation en fonction de ce qui a déjà été évalué dans le processus de validation. Ce module explique la notion de trace d’évaluation, les règles de détection des éléments évalués, et la manière d’appliquer ces opérateurs dans des schémas composés ou logiques.

Résultats d’apprentissage :

Expliquer le concept de trace d’évaluation et son rôle dans la validation

Déterminer ce qui est considéré comme “évalué” pendant la validation

Appliquer unevaluatedProperties pour interdire les propriétés non prévues

Appliquer unevaluatedItems pour interdire les éléments de tableau inattendus

Connaissances :

Fonctionnement du vocabulaire Unevaluated

Interaction entre applicateurs et composition de schémas

Gestion des propriétés et éléments non évalués

Compétences :

Créer des schémas robustes pour éviter les données imprévues

Combiner unevaluatedProperties et les opérateurs logiques

Utiliser les traces d’évaluation pour déboguer des schémas complexes

Aptitudes :

Concevoir des schémas précis et stricts tout en conservant la flexibilité de composition

Gérer efficacement les contraintes dynamiques dans des environnements multi-schémas

Module 11 :
Durée moyenne : 50 minutes.
Référencement dynamique et portée — concevoir des schémas extensibles avec $dynamicAnchor et $dynamicRef

Le référencement dynamique est l’une des fonctionnalités les plus avancées de JSON Schema. Il permet la création de schémas extensibles et génériques grâce aux mécanismes de portée dynamique et de résolution à l’exécution. Ce module explique la notion de dynamic scope (pile des ressources traversées lors de l’évaluation) et montre comment utiliser $dynamicAnchor et $dynamicRef pour construire des schémas polymorphes et évolutifs.

Résultats d’apprentissage :

Définir la portée dynamique comme la pile de ressources traversées lors de l’évaluation

Utiliser $dynamicAnchor pour enregistrer des fragments dans la portée dynamique

Utiliser $dynamicRef pour effectuer des résolutions à l’exécution

Concevoir des schémas extensibles et polymorphes

Connaissances :

Mécanismes de portée et de résolution dynamique

Fonctionnement de $dynamicAnchor et $dynamicRef

Applications du référencement dynamique dans les architectures extensibles

Compétences :

Créer des schémas génériques et réutilisables

Exploiter la résolution dynamique pour adapter la validation à différents contextes

Déboguer des schémas complexes utilisant des références imbriquées

Aptitudes :

Concevoir des schémas capables d’évoluer sans rupture de compatibilité

Mettre en œuvre des modèles de validation polymorphes dans des environnements réels

Module 12 :
Durée moyenne : 80 minutes.
Exploiter les annotations JSON Schema — extraire des métadonnées issues de la validation

JSON Schema ne sert pas uniquement à valider : il génère aussi des métadonnées appelées annotations, produites lors d’une validation réussie. Ce module explique le vocabulaire Meta-Data, les annotations issues des applicateurs (Applicator et Unevaluated), et la manière d’utiliser les mots-clés inconnus pour créer des annotations ad hoc. Il explore des applications concrètes pour la génération de documentation, de code et d’interfaces utilisateurs.

Résultats d’apprentissage :

Utiliser les mots-clés du vocabulaire Meta-Data pour documenter les schémas

Extraire des annotations des applicateurs lors de la validation

Créer des annotations personnalisées à l’aide de mots-clés inconnus

Comprendre les limites et implications de la collecte d’annotations

Exploiter les annotations pour générer documentation, code ou interfaces

Connaissances :

Fonctionnement des vocabulaires Meta-Data et Applicator

Différence entre validation et annotation dans JSON Schema

Production et collecte d’annotations lors de la validation

Compétences :

Concevoir des schémas documentés et auto-descriptifs

Utiliser les annotations pour alimenter des générateurs de code ou d’interface

Gérer les annotations dans des contextes de validation avancés

Aptitudes :

Créer des schémas réutilisables à fort potentiel documentaire

Optimiser les processus de génération et de visualisation à partir des schémas JSON

Module 13 :
Durée moyenne : 35 minutes.
Intégrer des données binaires dans JSON — le vocabulaire Content pour les données non-JSON

Bien que JSON soit un format textuel, les API doivent souvent transporter des données binaires, comme des images ou des fichiers. Ce module présente le vocabulaire Content, inspiré des standards de messagerie (RFC 2045). Il explique comment décrire les données encodées en texte via contentEncoding, déclarer les types MIME avec contentMediaType et structurer des formats imbriqués avec contentSchema.

Résultats d’apprentissage :

Utiliser contentEncoding pour décrire les transformations binaire-vers-texte

Déclarer les types MIME selon la norme RFC 6838 avec contentMediaType

Décrire des formats embarqués compatibles JSON avec contentSchema

Appliquer les annotations du vocabulaire Content pour la sérialisation et la désérialisation

Connaissances :

Standards de messagerie et codage binaire-texte

Fonctionnement du vocabulaire Content

Règles d’encodage et de décodage des données non textuelles

Compétences :

Décrire des contenus binaires dans des schémas JSON

Gérer la sérialisation et la désérialisation à partir des annotations Content

Créer des schémas intégrant différents types de données

Aptitudes :

Concevoir des schémas compatibles avec des contenus mixtes (texte et binaire)

Assurer la conformité des API manipulant des données non JSON

Module 14 :
Durée moyenne : 40 minutes.
Conception d’API “schema-first” — du modèle de données à la spécification OpenAPI de production

Ce dernier module réunit toutes les notions du parcours autour d’une approche schema-first pour concevoir des spécifications OpenAPI prêtes pour la production. Il présente les étapes de planification du domaine métier, de modélisation des données avec JSON Schema, de tests, de déploiement dans des registres et d’assemblage dans des spécifications OpenAPI.

Résultats d’apprentissage :

Concevoir un domaine et un modèle de données selon la méthode schema-first

Appliquer les bonnes pratiques de production JSON Schema

Mettre en œuvre des tests systématiques pour la qualité des schémas

Déployer des schémas dans des registres pour favoriser la réutilisation

Composer des schémas JSON dans des spécifications OpenAPI

Évaluer l’approche schema-first comme source unique de vérité pour la conception d’API

Connaissances :

Étapes du cycle de vie d’un schéma JSON en production

Intégration de JSON Schema dans les pipelines de qualité et de gouvernance API

Déploiement et versionnage dans des registres de schémas

Compétences :

Concevoir, tester et publier des schémas réutilisables

Intégrer JSON Schema dans les pratiques d’ingénierie OpenAPI

Garantir la cohérence entre conception, documentation et implémentation

Aptitudes :

Piloter une approche schema-first à l’échelle d’une organisation

Favoriser la collaboration inter-équipes autour d’un référentiel de schémas commun

• Ce parcours est composé de 14 modules
• Des évaluations de connaissances sont proposées à la fin de chaque module sous forme de quizz
• Chaque quizz validé avec un score de 10/10 débloque l’accès au module suivant
• Une certification de réussite est délivrée à l’issue du parcours complet
• Critères d’évaluation : justesse des réponses et validation de tous les modules

• Ouverture de l’accès 14 jours après la date de paiement, en application du délai légal de rétractation prévu par l’article L221-18 du Code de la consommation. Toutefois, l’apprenant peut demander un accès anticipé en renonçant expressément à son droit de rétractation, en remplissant le formulaire joint lors de l’inscription.

• Prix : 399 € HT
• Durée estimée : 11H30
• Accès libre pendant 6 mois, 24h/24

• Vidéos avec sous-titres en anglais
• Vitesse de lecture ajustable
• Le parcours est conçu pour être accessible aux personnes en situation de handicap
• Pour plus d’information et d’options, rendez-vous sur notre page dédiée

Une fois la convention de formation signée et le paiement effectué, vous recevrez un premier email confirmant la création de votre compte sur la plateforme. Lors de votre première connexion, il vous sera demandé de :

• • • modifier votre mot de passe,

    • lire et signer les conditions d’utilisation et la charte de protection des données.

Un second email vous informera ensuite de votre inscription à la formation. Le lien contenu vous mènera directement au début du parcours. Si ce n’est pas le cas, vous pouvez accéder à votre formation via Menu > My Progress.

Lors de la première étape du parcours, vous devrez valider votre identité : un code à usage unique sera envoyé à votre adresse email (qui constitue votre identifiant). Il vous suffira de le saisir dans la plateforme pour débloquer la suite du parcours.

Vous pouvez alors débuter votre formation. À la fin de chaque chapitre, cliquez sur « Next lesson » ou sélectionnez directement le chapitre suivant dans le syllabus. Pour accéder au module suivant après un quiz, utilisez le menu déroulant des modules situé au-dessus de la vidéo.

À la fin de votre parcours, une nouvelle étape de vérification d’identité aura lieu afin de débloquer votre certificat et valider officiellement votre formation.

Plus de détail sur cette page, et en cas de questions, notre équipe reste disponible à l’adresse : apimasters@apidays.io

Notre équipe se tient à votre disposition du lundi au vendredi de 9h à 17h pour toute question technique ou pédagogique.

Vous pouvez nous contacter à l’adresse suivante : apimasters@apidays.io

Dans le cadre de notre engagement qualité, nous accompagnons chaque apprenant :

• avant la formation (informations, prérequis, accessibilité),

• pendant la formation (assistance technique, accompagnement pédagogique personnalisé),

• et après la formation (support post-formation, évaluation à chaud et à froid).

Un référent pédagogique et un référent technique sont disponibles pour vous accompagner tout au long de votre parcours.

En cas de dysfonctionnement technique lié à notre plateforme d’apprentissage (hébergée par un prestataire tiers), notre équipe fera le lien avec le prestataire pour assurer une résolution dans les meilleurs délais. Les délais de traitement peuvent varier en fonction de la nature du problème et des procédures du prestataire.

Cette checklist vous aide à vérifier si le cours correspond à votre profil et à vos attentes. Le contenu suivant est volontairement en anglais pour valider votre niveau, requis pour suivre le parcours.

This course is probably right for you if:

• You already use OpenAPI (Swagger) or AsyncAPI to document or design APIs and want to understand what’s happening “under the hood.”

• You work as a Backend Developer, API Architect, or QA Engineer, and want to write or validate more reliable API specifications.

• You’ve encountered validation errors in OpenAPI and wish you knew why a schema works—or fails.

• You want to understand advanced keywords like allOf, oneOf, enum or pattern.

• You’re involved in API governance or quality assurance and want to standardize API schemas across your organization.

• You’re comfortable reading and listening to technical English (the course includes explanations and examples in English).

• You aim to strengthen your technical foundations to contribute more effectively to OpenAPI and AsyncAPI design discussions.

This course might not be the right fit if:

• You are completely new to the concept of JSON or have never read a JSON file before.

• You are looking for a beginner-level introduction to APIs or JSON syntax.

• You want a hands-on coding course rather than a deep dive into the standards and theory behind API specifications.

• You’re not yet comfortable following English technical content without translation or subtitles.

Still unsure? You can contact us (apimasters@apidays.io) or pass the short prerequisites test to confirm your readiness.