API Android Developer Console

L'API Android Developer Console est un service RESTful qui permet aux développeurs validés d'automatiser les workflows de validation des développeurs Android dans l'Android Developer Console, y compris la récupération des comptes de développeur, la vérification des critères d'éligibilité des clés, l'enregistrement des noms de packages Android, l'enregistrement des clés de signature d'application et la validation de la propriété des clés.

Remarque : Pour obtenir des instructions de configuration détaillées, y compris pour activer l'API dans la console Google Cloud, configurer les identifiants du serveur Web OAuth 2.0 et intégrer votre pipeline de compilation, consultez Enregistrer des noms de packages avec l'API Android Developer Console.

Présentation, cas d'utilisation et contexte de mise en œuvre

Principaux cas d'utilisation et fonctionnalités

• Enregistrement automatisé des noms de packages CI/CD : enregistrez des dizaines ou des centaines de noms de packages Android de manière programmatique (CreateAndroidPackage).
• Inspection préalable de l'historique des règles de clé : vérifiez de manière programmatique si Google a déjà observé un nom de package dans l'écosystème et si l'enregistrement d'un certificat de signature spécifique nécessite la validation de la propriété de la clé (GetAndroidPackageRegistrationPolicy).
• Enregistrement automatisé de la clé de signature d'application et validation de la propriété : enregistrez les empreintes SHA-256 du certificat de signature public (CreateAndroidPackageKey), récupérez des jetons de vérification uniques (verificationToken) et automatisez la preuve de possession de la clé privée à l'aide d'importations d'APK signés à requête unique ou réutilisables (VerifyAndroidPackageKeyOwnership).
• Envoi de justifications par programmation : envoyez des justifications de propriété (JustifyAndroidPackageKeyRegistration).
• Surveillance de l'état : surveillez l'état de l'enregistrement sur les comptes de développeur, les noms de package et les clés de signature d'application (GetDeveloperAccount, ListDeveloperAccounts, GetAndroidPackage, ListAndroidPackages, GetAndroidPackageKey, ListAndroidPackageKeys).

Workflow d'implémentation de bout en bout

1. Valider l'identité du développeur une fois dans l'UI : validez l'identité du développeur (INDIVIDUAL ou ORGANIZATION) dans la Android Developer Console pour que verificationState soit VERIFIED.
2. Activez l'API et authentifiez-vous : activez androiddeveloperconsole.googleapis.com dans votre projet Google Cloud et obtenez un jeton d'accès Bearer OAuth 2.0 délégué par l'utilisateur avec le champ d'application https://www.googleapis.com/auth/androiddeveloperconsole.
3. Découvrez le nom de ressource de votre compte de développeur : appelez GET /v1/developerAccounts (ListDeveloperAccounts) pour récupérer developerAccounts/{developer_account} et vérifier que verificationState est VERIFIED.
4. Vérifier la règle d'enregistrement pour le nom du package : appelez GET /v1/developerAccounts/{id}/androidPackages/{pkg}/registrationPolicy (GetAndroidPackageRegistrationPolicy) pour inspecter keySelectionStrategy (SELECT_KEY_FROM_LIST ou USE_ANY_KEY) et toutes les clés de signature historiques connues (knownKeys).
5. Créer la ressource de package Android : appelez POST /v1/developerAccounts/{id}/androidPackages?androidPackageId={pkg} (CreateAndroidPackage) avec le corps {"name": ""} (crée la ressource à l'état DRAFT).
6. Enregistrez l'empreinte de votre clé de signature d'application : appelez POST /v1/developerAccounts/{id}/androidPackages/{pkg}/keys (CreateAndroidPackageKey) avec le corps JSON {"certificateFingerprintSha256": "..."}. Inspectez l'état renvoyé :
   • DRAFT : une preuve de propriété de la clé privée est requise, et la réponse inclut un verificationToken unique pour l'étape 7.
   • IN_REVIEW : la preuve de propriété et la justification sont ignorées automatiquement (par exemple, lors de l'enregistrement d'un nouveau nom de package qui n'a jamais été vu sur Android, ou lorsque vous avez déjà validé la propriété de cette clé de signature pour un autre nom de package dans le même DeveloperAccount). Ignorez l'étape 7 et l'appel de justification à l'étape 8, puis passez directement à l'interrogation de GetAndroidPackage et GetAndroidPackageKey.
7. Créer et importer l'APK de validation (si l'état est DRAFT) : intégrez la chaîne verificationToken renvoyée dans assets/adi-registration.properties dans un APK minimal correspondant à packageName, signez-le avec votre clé de signature d'application privée, puis importez-le à l'aide de POST /upload/v1/developerAccounts/{id}/androidPackages/{pkg}/keys/{sha256}:verify (VerifyAndroidPackageKeyOwnership).
8. Envoyer la justification (si nécessaire) et interroger l'état d'enregistrement : si la clé est à l'état OWNERSHIP_VERIFIED et que registrationJustificationRequired est défini sur true, appelez POST /v1/developerAccounts/{id}/androidPackages/{pkg}/keys/{sha256}:justifyAndroidPackageKeyRegistration (JustifyAndroidPackageKeyRegistration). Interrogez GetAndroidPackage et GetAndroidPackageKey jusqu'à ce que state atteigne REGISTERED.

Commandes CLI locales pour préparer les empreintes de clé et les APK de validation

• Extraire l'empreinte du certificat SHA-256 d'un keystore (keytool) :

  keytool -list -v -keystore release-key.jks -alias my-key-alias

• Vérifier le condensé du certificat de signature SHA-256 sur un APK compilé (apksigner) :

  apksigner verify --print-certs app-release.apk

• Inspectez le nom du package APK et le fichier de jeton intégré avant l'importation (aapt2 et unzip) :

  aapt2 dump badging app-release.apk | head -n 1
  unzip -p app-release.apk assets/adi-registration.properties

Fonctionnalités de l'UI et de l'API Android Developer Console

Tâche	UI Web d'Android Developer Console (android.google.com/developerconsole)	API Android Developer Console
Validation de l'identité du développeur (KYC/KYB) et paiement des frais	Compatible (condition préalable unique requise)	Non compatible avec l'API (vérification de l'état en lecture seule à l'aide de GetDeveloperAccount et ListDeveloperAccounts)
Afficher les comptes de développeur associés	Sélecteur de compte dans l'en-tête de la console	GET /v1/developerAccounts (ListDeveloperAccounts)
Inspecter l'historique des clés de signature et des règles pour un nom de package	S'affiche pendant l'assistant "Enregistrer le nom de package"	GET /v1/.../registrationPolicy (GetAndroidPackageRegistrationPolicy)
Enregistrer un nouveau nom de package Android	Noms de packages > Enregistrer le nom de package	POST /v1/{parent}/androidPackages?androidPackageId=... (CreateAndroidPackage)
Afficher ou lister les noms de packages enregistrés et les brouillons	Tableau de bord "Noms de packages"	GET /v1/{name} (GetAndroidPackage), GET /v1/{parent}/androidPackages (ListAndroidPackages)
Ajouter une clé de signature d'application et générer un jeton de vérification	Détails du package > Ajouter une clé de signature	POST /v1/{parent}/keys (CreateAndroidPackageKey)
Prouver la propriété de la clé privée (adi-registration.properties)	Importer l'APK d'extrait signé dans l'UI de la console	POST /upload/v1/{name}:verify (VerifyAndroidPackageKeyOwnership)
Envoyer une justification lorsque la clé nécessite un examen manuel	Prompt textuel pendant le workflow d'enregistrement de la clé	POST /v1/{name}:justifyAndroidPackageKeyRegistration (JustifyAndroidPackageKeyRegistration)

Configuration et authentification du service

Toutes les requêtes API doivent utiliser HTTPS et inclure un en-tête Authorization: Bearer ACCESS_TOKEN obtenu à l'aide du flux de serveur Web OAuth 2.0 pour un compte Google ayant validé l'identité du développeur dans la Android Developer Console.

Propriété	Valeur
Point de terminaison REST de base	https://androiddeveloperconsole.googleapis.com
Point de terminaison d'importation de contenus multimédias	https://androiddeveloperconsole.googleapis.com/upload
Version de l'API	v1
Champ d'application OAuth 2.0 requis	https://www.googleapis.com/auth/androiddeveloperconsole
Limite de quota par défaut	2,000 requêtes par jour, par projet Google Cloud et par méthode

Remarque : L'authentification nécessite des identifiants OAuth 2.0 délégués par l'utilisateur (Authorization: Bearer ACCESS_TOKEN). Les comptes de service, la fédération d'identité de charge de travail et les clés API ne sont pas acceptés, car les comptes Android Developer Console sont directement associés à des comptes Google d'utilisateurs validés.

Ressources et points de terminaison de l'API

L'API Android Developer Console organise les ressources selon la hiérarchie suivante :

• DeveloperAccount (developerAccounts/{developer_account})
  • AndroidPackage (developerAccounts/{developer_account}/androidPackages/{android_package})
    • AndroidPackageRegistrationPolicy (developerAccounts/{developer_account}/androidPackages/{android_package}/registrationPolicy)
    • AndroidPackageKey (developerAccounts/{developer_account}/androidPackages/{android_package}/keys/{key})

Ressource : DeveloperAccount

Représente un compte dans la Android Developer Console associé à une identité de développeur.

Champ	Type	Description
name	string	Identifiant. Nom de la ressource au format developerAccounts/{developer_account}.
displayName	string	Uniquement en sortie. Nom lisible par l'humain associé au compte de développeur (nom de la personne ou de l'organisation).
verificationState	enum (VerificationState)	Uniquement en sortie. État actuel de la validation de l'identité du développeur pour le compte.

Énumération : DeveloperAccount.VerificationState

Valeur	Description
VERIFIED	La validation de l'identité du développeur est terminée. Le compte peut enregistrer des noms de packages et des clés de signature d'application.
NOT_VERIFIED	La validation de l'identité du développeur n'a pas été effectuée dans l'Android Developer Console.

Méthodes : DeveloperAccount

Méthode	Requête HTTP	Description
GetDeveloperAccount	GET /v1/{name=developerAccounts/*}	Récupère les métadonnées et l'état de validation d'un seul DeveloperAccount.
ListDeveloperAccounts	GET /v1/developerAccounts	Répertorie tous les objets DeveloperAccount accessibles au compte Google authentifié (sans pagination).

Ressource : AndroidPackage

Représente un nom de package Android enregistré ou en cours d'enregistrement sous un DeveloperAccount.

Champ	Type	Description
name	string	Identifiant. Nom de la ressource au format developerAccounts/{developer_account}/androidPackages/{android_package}, où {android_package} est le nom du package Android (par exemple, com.example.myapp).
packageName	string	Uniquement en sortie. Nom du package Android (par exemple, com.example.myapp).
state	enum (AndroidPackage.State)	Uniquement en sortie. État actuel du cycle de vie de l'enregistrement du nom de package.
registeredAppStore	boolean	Uniquement en sortie. Indique si ce nom de package est actuellement actif en tant que magasin d'applications enregistré.

Énumération : AndroidPackage.State

Valeur	Description
DRAFT	La ressource de nom de package a été créée, et l'enregistrement de la clé de signature d'application ou la validation de la propriété sont toujours en cours.
IN_REVIEW	L'enregistrement du nom de package et la justification de la clé requise ont été envoyés et sont en cours d'examen par Google. Un package passe de l'état DRAFT à l'état IN_REVIEW soit immédiatement après l'CreateAndroidPackageKey (lorsque la validation de la propriété de la clé est ignorée, y compris lorsque la clé a déjà été validée pour un autre nom de package dans le même DeveloperAccount), soit après avoir terminé l'VerifyAndroidPackageKeyOwnership et, si nécessaire, l'JustifyAndroidPackageKeyRegistration.
REGISTERED	Le nom de package est enregistré pour ce compte de développeur pour la validation des développeurs Android.
PENDING_TRANSFER	Le nom de package est en attente de transfert de propriété vers un autre compte de développeur.

Ressource : AndroidPackageRegistrationPolicy

Ressource singleton renvoyée par GetAndroidPackageRegistrationPolicy qui décrit les clés de signature publiques historiques détectées pour un nom de package et indique si l'enregistrement du nom de package avec une clé de signature donnée nécessite une justification écrite.

Champ	Type	Description
name	string	Identifiant. Nom de la ressource au format developerAccounts/{developer_account}/androidPackages/{android_package}/registrationPolicy.
knownKeys[]	object (KnownKey)	Liste des anciennes clés de signature d'application précédemment observées pour la distribution d'applications avec ce nom de package, triées par ordre lexicographique par certificateFingerprintSha256.
knownKeys[].certificateFingerprintSha256	string	Uniquement en sortie. Empreinte SHA-256 hexadécimale normalisée en minuscules de 64 caractères du certificat de signature historique (sans deux-points).
knownKeys[].justificationRequirement	enum (JustificationRequirement)	Uniquement en sortie. Indique si l'enregistrement de cette clé nécessite d'appeler JustifyAndroidPackageKeyRegistration (REQUIRED ou NOT_REQUIRED). Si la clé de signature a déjà été validée sur un autre nom de package sous le même DeveloperAccount, VerifyAndroidPackageKeyOwnership et JustifyAndroidPackageKeyRegistration sont ignorés, même si justificationRequirement est défini sur REQUIRED.
keySelectionStrategy	enum (KeySelectionStrategy)	Uniquement en sortie. Règle de sélection de clé pour l'enregistrement de ce nom de package : SELECT_KEY_FROM_LIST (vous devez enregistrer une clé de knownKeys) ou USE_ANY_KEY (vous pouvez enregistrer n'importe quelle clé de signature d'application valide appartenant au développeur).

Énumération : KnownKey.JustificationRequirement

Valeur	Description
REQUIRED	Pour enregistrer cette clé connue, vous devez envoyer une justification écrite à l'aide de JustifyAndroidPackageKeyRegistration après avoir effectué l'étape VerifyAndroidPackageKeyOwnership (sauf si la clé a déjà été validée sur un autre nom de package sous le même DeveloperAccount, auquel cas les étapes VerifyAndroidPackageKeyOwnership et JustifyAndroidPackageKeyRegistration sont ignorées).
NOT_REQUIRED	L'enregistrement de cette clé connue ne nécessite aucune justification. La clé passe directement à l'état IN_REVIEW après VerifyAndroidPackageKeyOwnership (ou immédiatement après CreateAndroidPackageKey si la clé a déjà été validée sur un autre nom de package sous le même DeveloperAccount).

Énumération : AndroidPackageRegistrationPolicy.KeySelectionStrategy

Valeur	Description
SELECT_KEY_FROM_LIST	L'appelant doit enregistrer l'une des clés historiques listées dans knownKeys.
USE_ANY_KEY	En plus des clés de knownKeys, l'appelant peut enregistrer n'importe quelle clé de signature d'application valide qui n'a pas été observée précédemment dans l'écosystème Android.

Méthodes : AndroidPackage

Méthode	Requête HTTP	Description
GetAndroidPackageRegistrationPolicy	GET /v1/{name=developerAccounts/*/androidPackages/*/registrationPolicy}	Récupère la stratégie de sélection de clé et les clés de signature historiques connues pour un nom de package.
CreateAndroidPackage	POST /v1/{parent=developerAccounts/*}/androidPackages?androidPackageId={package_name}	Crée une ressource AndroidPackage à l'état DRAFT pour commencer à enregistrer un nom de package.
GetAndroidPackage	GET /v1/{name=developerAccounts/*/androidPackages/*}	Récupère les détails et l'état d'enregistrement actuel d'un AndroidPackage existant.
ListAndroidPackages	GET /v1/{parent=developerAccounts/*}/androidPackages	Répertorie les objets AndroidPackage sous un DeveloperAccount (pageSize max 1000, pageToken).

Ressource : AndroidPackageKey

Représente l'empreinte d'un certificat public de signature d'application associé à un AndroidPackage et suit l'état de la validation de la propriété et de l'examen de l'enregistrement.

Champ	Type	Description
name	string	Identifiant. Nom de ressource attribué par le serveur au format developerAccounts/{developer_account}/androidPackages/{android_package}/keys/{key}, où {key} est une empreinte SHA-256 hexadécimale normalisée de 64 caractères en minuscules, sans deux-points. Doit être omis ou vide lors de l'appel de CreateAndroidPackageKey.
certificateFingerprintSha256	string	Obligatoire. Immuable. Hachage SHA-256 du certificat de signature d'application. En entrée dans CreateAndroidPackageKey, accepte soit un hexadécimal brut de 64 caractères (60e860e8...), soit un hexadécimal séparé par des deux-points (60:E8:60:E8:...). En sortie, toujours normalisé en hexadécimal minuscule de 64 caractères sans deux-points.
state	enum (AndroidPackageKey.State)	Uniquement en sortie. État actuel du cycle de vie de la validation et de l'enregistrement de la clé.
verificationToken	string	Uniquement en sortie. Jeton de test d'authentification unique généré par Google. Utilisé uniquement lorsque l'état est DRAFT (peut être ignoré lorsque CreateAndroidPackageKey fait passer la clé directement à IN_REVIEW). Lorsque l'état est DRAFT, intégrez cette chaîne dans assets/adi-registration.properties dans un APK signé pour terminer VerifyAndroidPackageKeyOwnership.
registrationJustificationRequired	boolean	Uniquement en sortie. Si true et que la clé est à l'état OWNERSHIP_VERIFIED, vous devez envoyer une justification écrite à l'aide de JustifyAndroidPackageKeyRegistration avant que l'enregistrement ne passe à l'état IN_REVIEW. Si CreateAndroidPackageKey fait passer la clé directement à l'état IN_REVIEW (car la clé a déjà été validée sur un autre nom de package dans le même DeveloperAccount), la justification est ignorée.

Énumération : AndroidPackageKey.State

Valeur	Description
DRAFT	La ressource de clé a été créée, et la preuve de possession de la clé privée à l'aide de l'importation d'un APK signé (VerifyAndroidPackageKeyOwnership) est toujours requise, car la propriété de cette clé n'a pas encore été validée pour un nom de package sous ce DeveloperAccount.
OWNERSHIP_VERIFIED	La propriété de la clé privée a été validée à l'aide d'un APK signé importé. Si registrationJustificationRequired est défini sur true, une justification est toujours requise avant le début de l'examen.
IN_REVIEW	L'enregistrement de la clé est en cours d'examen par Google. Une clé passe à cet état immédiatement après l'état CreateAndroidPackageKey lorsqu'une preuve de propriété n'est pas requise (par exemple, pour un nouveau nom de package jamais enregistré sur Android ou lorsque la clé a déjà été validée sur un autre nom de package sous le même DeveloperAccount, ce qui permet également d'ignorer l'état JustifyAndroidPackageKeyRegistration), directement après l'état VerifyAndroidPackageKeyOwnership (si registrationJustificationRequired est false) ou après l'état JustifyAndroidPackageKeyRegistration (si registrationJustificationRequired est true).
REGISTERED	La clé de signature d'application est activement enregistrée pour ce nom de package pour la validation des développeurs Android.
PENDING_TRANSFER	L'enregistrement de la clé de signature d'application est en attente de la finalisation d'un transfert.

Méthodes : AndroidPackageKey

Méthode	Requête HTTP	Description
CreateAndroidPackageKey	POST /v1/{parent=developerAccounts/*/androidPackages/*}/keys	Enregistre une nouvelle empreinte SHA-256 de certificat de signature d'application sous un AndroidPackage. Renvoie la clé à l'état DRAFT (lorsqu'une preuve de propriété à l'aide de VerifyAndroidPackageKeyOwnership est requise) ou directement à l'état IN_REVIEW (lorsque la validation de la propriété est ignorée, par exemple pour un nouveau nom de package jamais enregistré sur Android ou une clé déjà validée sur un autre nom de package dans le même DeveloperAccount).
GetAndroidPackageKey	GET /v1/{name=developerAccounts/*/androidPackages/*/keys/*}	Récupère l'état, l'empreinte et les métadonnées de validation d'un AndroidPackageKey spécifique.
ListAndroidPackageKeys	GET /v1/{parent=developerAccounts/*/androidPackages/*}/keys	Répertorie tous les objets AndroidPackageKey enregistrés sous un AndroidPackage (pageSize max 1000, pageToken).
VerifyAndroidPackageKeyOwnership	POST /upload/v1/{name=developerAccounts/*/androidPackages/*/keys/*}:verify	Importe un APK minimal signé contenant verificationToken dans assets/adi-registration.properties pour valider la propriété de la clé privée et envoyer les clés prêtes pour examen.
JustifyAndroidPackageKeyRegistration	POST /v1/{name=developerAccounts/*/androidPackages/*/keys/*}:justifyAndroidPackageKeyRegistration	Envoie un contexte de justification supplémentaire lorsque registrationJustificationRequired est défini sur true et envoie les clés validées pour examen.

Gestion des exceptions

Lorsqu'une requête API échoue, l'API Android Developer Console renvoie un code d'état HTTP 4xx ou 5xx et un corps d'erreur JSON google.rpc.Status standard :

{
  "error": {
    "code": 400,
    "message": "Invalid certificate fingerprint SHA256 format.",
    "status": "INVALID_ARGUMENT",
    "details": []
  }
}

Codes d'état HTTP et solutions courantes

Code HTTP	État gRPC	Causes courantes	Solution
400 Bad Request	INVALID_ARGUMENT	androidPackageId de style Java manquant ou non valide ; format certificateFingerprintSha256 non valide ; champ name non vide sur CreateAndroidPackage ou CreateAndroidPackageKey ; l'APK importé n'est pas signé, est corrompu, ne contient pas assets/adi-registration.properties, ne contient pas de verificationToken correspondant ou est signé avec un certificat non concordant.	Validez les formats de requête par rapport aux schémas de ressources, omettez ou videz name lors des appels de création, et vérifiez la signature de votre APK et le jeton intégré à l'aide de apksigner verify --print-certs et unzip -p app-release.apk assets/adi-registration.properties avant l'importation.
400 Bad Request	FAILED_PRECONDITION	DeveloperAccount a verificationState: NOT_VERIFIED ; la sélection de la clé ne respecte pas AndroidPackageRegistrationPolicy (SELECT_KEY_FROM_LIST) ; appel de VerifyAndroidPackageKeyOwnership ou JustifyAndroidPackageKeyRegistration dans un état non éligible.	Validez l'identité du développeur dans la Android Developer Console, vérifiez d'abord GetAndroidPackageRegistrationPolicy et inspectez l'état actuel de la ressource (state).
401 Unauthorized	UNAUTHENTICATED	Jeton d'accès Bearer OAuth 2.0 manquant, expiré ou non valide, ou tentative d'authentification à l'aide d'une clé API ou d'un compte de service.	Obtenez un nouveau jeton d'accès Bearer OAuth 2.0 délégué par l'utilisateur avec le champ d'application https://www.googleapis.com/auth/androiddeveloperconsole.
403 Forbidden	PERMISSION_DENIED	L'utilisateur authentifié ne dispose pas des autorisations nécessaires sur l'élément DeveloperAccount ou AndroidPackage cible, ou l'API Android Developer Console n'est pas activée sur le projet Google Cloud.	Vérifiez l'appartenance au compte à l'aide de ListDeveloperAccounts et assurez-vous que androiddeveloperconsole.googleapis.com est activé dans la console Google Cloud.
404 Not Found	NOT_FOUND	Le chemin d'accès à la ressource DeveloperAccount, AndroidPackage ou AndroidPackageKey spécifié n'existe pas.	Confirmez les chemins d'accès aux ressources à l'aide de ListDeveloperAccounts, ListAndroidPackages ou ListAndroidPackageKeys. Assurez-vous que les ID {key} utilisent des caractères hexadécimaux minuscules sans deux-points.
409 Conflict	ALREADY_EXISTS	Le nom du package ou l'empreinte du certificat SHA-256 sont déjà enregistrés sous ce compte de développeur ou un autre.	Inspectez les enregistrements existants à l'aide de GetAndroidPackage ou GetAndroidPackageKey, ou vérifiez l'historique de propriété à l'aide de GetAndroidPackageRegistrationPolicy.
429 Too Many Requests	RESOURCE_EXHAUSTED	Le quota par méthode de 2,000 requêtes par jour et par projet Google Cloud a été dépassé.	Implémentez un intervalle exponentiel entre les tentatives avec gigue et évitez les boucles d'interrogation à haute fréquence.
500/503	INTERNAL/UNAVAILABLE	Erreur de backend temporaire ou indisponibilité temporaire du service.	Réessayez les requêtes idempotentes avec une temporisation de retransmission exponentielle tronquée.

Exemples de requêtes et de réponses HTTP

Remplacez les valeurs d'espace réservé telles que ACCESS_TOKEN, 1234567890, com.example.myapp et 60e860e8... par vos propres valeurs.

1. GetDeveloperAccount

curl -X GET \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  "https://androiddeveloperconsole.googleapis.com/v1/developerAccounts/1234567890"

Réponse :

{
  "name": "developerAccounts/1234567890",
  "displayName": "Example Developer",
  "verificationState": "VERIFIED"
}

2. ListDeveloperAccounts

curl -X GET \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  "https://androiddeveloperconsole.googleapis.com/v1/developerAccounts"

Réponse :

{
  "developerAccounts": [
    {
      "name": "developerAccounts/1234567890",
      "displayName": "Example Developer",
      "verificationState": "VERIFIED"
    }
  ]
}

3. GetAndroidPackageRegistrationPolicy

curl -X GET \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  "https://androiddeveloperconsole.googleapis.com/v1/developerAccounts/1234567890/androidPackages/com.example.myapp/registrationPolicy"

Réponse :

{
  "name": "developerAccounts/1234567890/androidPackages/com.example.myapp/registrationPolicy",
  "knownKeys": [
    {
      "certificateFingerprintSha256": "60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123",
      "justificationRequirement": "NOT_REQUIRED"
    }
  ],
  "keySelectionStrategy": "SELECT_KEY_FROM_LIST"
}

4. CreateAndroidPackage

curl -X POST \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "Content-Type: application/json; charset=utf-8" \
  -d '{"name": ""}' \
  "https://androiddeveloperconsole.googleapis.com/v1/developerAccounts/1234567890/androidPackages?androidPackageId=com.example.myapp"

Réponse :

{
  "name": "developerAccounts/1234567890/androidPackages/com.example.myapp",
  "packageName": "com.example.myapp",
  "state": "DRAFT",
  "registeredAppStore": false
}

5. GetAndroidPackage

curl -X GET \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  "https://androiddeveloperconsole.googleapis.com/v1/developerAccounts/1234567890/androidPackages/com.example.myapp"

Réponse :

{
  "name": "developerAccounts/1234567890/androidPackages/com.example.myapp",
  "packageName": "com.example.myapp",
  "state": "REGISTERED",
  "registeredAppStore": false
}

6. ListAndroidPackages

curl -X GET \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  "https://androiddeveloperconsole.googleapis.com/v1/developerAccounts/1234567890/androidPackages?pageSize=100"

Réponse :

{
  "androidPackages": [
    {
      "name": "developerAccounts/1234567890/androidPackages/com.example.myapp",
      "packageName": "com.example.myapp",
      "state": "REGISTERED",
      "registeredAppStore": false
    }
  ],
  "nextPageToken": ""
}

7. CreateAndroidPackageKey

curl -X POST \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "Content-Type: application/json; charset=utf-8" \
  -d '{
    "certificateFingerprintSha256": "60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123"
  }' \
  "https://androiddeveloperconsole.googleapis.com/v1/developerAccounts/1234567890/androidPackages/com.example.myapp/keys"

Réponse :

{
  "name": "developerAccounts/1234567890/androidPackages/com.example.myapp/keys/60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123",
  "certificateFingerprintSha256": "60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123",
  "state": "DRAFT",
  "verificationToken": "token_xyz987654321"
}

Remarque : state est DRAFT lorsqu'une preuve de propriété de la clé privée est requise. Si la validation de la propriété n'est pas requise (par exemple, lors de l'enregistrement d'un nouveau nom de package jamais enregistré sur Android ou lorsque cette clé a déjà été validée sur un autre nom de package sous le même DeveloperAccount), CreateAndroidPackageKey renvoie l'état IN_REVIEW et met automatiquement la clé en file d'attente pour examen. Dans ce cas, n'appelez pas VerifyAndroidPackageKeyOwnership (exemple 10) ni JustifyAndroidPackageKeyRegistration (exemple 11).

8. GetAndroidPackageKey

curl -X GET \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  "https://androiddeveloperconsole.googleapis.com/v1/developerAccounts/1234567890/androidPackages/com.example.myapp/keys/60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123"

Réponse :

{
  "name": "developerAccounts/1234567890/androidPackages/com.example.myapp/keys/60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123",
  "certificateFingerprintSha256": "60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123",
  "state": "REGISTERED"
}

9. ListAndroidPackageKeys

curl -X GET \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  "https://androiddeveloperconsole.googleapis.com/v1/developerAccounts/1234567890/androidPackages/com.example.myapp/keys?pageSize=100"

Réponse :

{
  "androidPackageKeys": [
    {
      "name": "developerAccounts/1234567890/androidPackages/com.example.myapp/keys/60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123",
      "certificateFingerprintSha256": "60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123",
      "state": "REGISTERED"
    }
  ],
  "nextPageToken": ""
}

10. VerifyAndroidPackageKeyOwnership

Option A : Importation de contenus multimédias via une requête unique

curl -X POST \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @app-release.apk \
  "https://androiddeveloperconsole.googleapis.com/upload/v1/developerAccounts/1234567890/androidPackages/com.example.myapp/keys/60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123:verify?uploadType=media"

Option B : Protocole d'importation avec reprise (recommandé pour les fichiers APK volumineux ou l'intégration/le déploiement continus)

Étape 1 : Démarrez la session d'importation avec reprise et extrayez l'en-tête X-Goog-Upload-URL renvoyé :

curl -i -X POST \
  "https://androiddeveloperconsole.googleapis.com/upload/v1/developerAccounts/1234567890/androidPackages/com.example.myapp/keys/60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123:verify" \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: FILE_SIZE_IN_BYTES" \
  -H "X-Goog-Upload-Header-Content-Type: application/vnd.android.package-archive" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "developerAccounts/1234567890/androidPackages/com.example.myapp/keys/60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123"
  }'

Étape 2 : Importez le binaire APK signé dans UPLOAD_SESSION_URI et finalisez la session :

curl -X PUT \
  "UPLOAD_SESSION_URI" \
  -H "Content-Length: FILE_SIZE_IN_BYTES" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@app-release.apk"

Réponse :

{
  "name": "developerAccounts/1234567890/androidPackages/com.example.myapp/keys/60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123",
  "certificateFingerprintSha256": "60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123",
  "state": "IN_REVIEW"
}

11. JustifyAndroidPackageKeyRegistration

curl -X POST \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "Content-Type: application/json; charset=utf-8" \
  -d '{
    "justification": "We previously distributed com.example.myapp directly from https://downloads.example.com and are migrating to our rotated production key."
  }' \
  "https://androiddeveloperconsole.googleapis.com/v1/developerAccounts/1234567890/androidPackages/com.example.myapp/keys/60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123:justifyAndroidPackageKeyRegistration"

Réponse :

{
  "name": "developerAccounts/1234567890/androidPackages/com.example.myapp/keys/60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123",
  "certificateFingerprintSha256": "60e860e8d77251234567890abcdef1234567890abcdef1234567890abcdef123",
  "state": "IN_REVIEW",
  "registrationJustificationRequired": true
}

Ressources supplémentaires

• Enregistrer des noms de packages avec l'API Android Developer Console
• Vérifier l'état d'enregistrement d'une application avec l'API Android Developer ID Status
• S'enregistrer sur Android Developer Console
• S'inscrire sur la Google Play Console