Android Developer Console API

Die Android Developer Console API ist ein RESTful-Dienst, mit dem bestätigte Entwickler Workflows zur Bestätigung für Android-Entwickler in der Android Developer Console automatisieren können. Dazu gehören das Abrufen von Entwicklerkonten, das Prüfen der wichtigsten Teilnahmevoraussetzungen, das Registrieren von Android-Paketnamen, das Registrieren von App-Signaturschlüsseln und das Bestätigen der Inhaberschaft von Schlüsseln.

Hinweis: Eine detaillierte Anleitung zur Einrichtung, einschließlich der Aktivierung der API in der Google Cloud Console, der Konfiguration von OAuth 2.0-Webserver-Anmeldedaten und der Einbindung in Ihre Build-Pipeline, finden Sie unter Paketnamen mit der Android Developer Console API registrieren.

Übersicht, Anwendungsfälle und Implementierungskontext

Wichtige Anwendungsfälle und Funktionen

• Automatisierte Registrierung von Paketnamen über CI/CD:Sie können Dutzende oder Hunderte von Android-Paketnamen programmatisch registrieren (CreateAndroidPackage).
• Prüfung der bisherigen Schlüsselrichtlinie vor der Veröffentlichung:Programmatisch prüfen, ob Google bereits einen Paketnamen im Ökosystem beobachtet hat und ob für die Registrierung eines bestimmten Signaturzertifikats eine Bestätigung der Schlüsselinhaberschaft (GetAndroidPackageRegistrationPolicy) erforderlich ist.
• Automatisierte Registrierung von App-Signaturschlüsseln und Bestätigung der Inhaberschaft:Registrieren Sie SHA-256-Fingerabdrücke für öffentliche Signaturzertifikate (CreateAndroidPackageKey), rufen Sie eindeutige Bestätigungs-Challenge-Tokens ab (verificationToken) und automatisieren Sie den Nachweis des Besitzes privater Schlüssel mithilfe von signierten APK-Uploads mit einer einzelnen Anfrage oder fortsetzbaren Uploads (VerifyAndroidPackageKeyOwnership).
• Programmatische Einreichung der Begründung:Reichen Sie Begründungen für die Inhaberschaft ein (JustifyAndroidPackageKeyRegistration).
• Statusüberwachung:Sie können den Registrierungsstatus für Entwicklerkonten, Paketnamen und App-Signaturschlüssel überwachen (GetDeveloperAccount, ListDeveloperAccounts, GetAndroidPackage, ListAndroidPackages, GetAndroidPackageKey, ListAndroidPackageKeys).

End-to-End-Implementierungsworkflow

1. Entwickleridentität einmalig in der Benutzeroberfläche bestätigen:Schließen Sie die Bestätigung der Entwickleridentität (INDIVIDUAL oder ORGANIZATION) in der Android Developer Console ab, damit verificationState VERIFIED ist.
2. API aktivieren und authentifizieren: Aktivieren Sie androiddeveloperconsole.googleapis.com in Ihrem Google Cloud-Projekt und rufen Sie ein nutzerdelegiertes OAuth 2.0-Inhaber-Zugriffstoken mit dem Bereich https://www.googleapis.com/auth/androiddeveloperconsole ab.
3. Ressourcennamen Ihres Entwicklerkontos ermitteln:Rufen Sie GET /v1/developerAccounts (ListDeveloperAccounts) auf, um developerAccounts/{developer_account} abzurufen, und prüfen Sie, ob verificationState den Wert VERIFIED hat.
4. Registrierungsrichtlinie für den Paketnamen prüfen:Rufen Sie GET /v1/developerAccounts/{id}/androidPackages/{pkg}/registrationPolicy (GetAndroidPackageRegistrationPolicy) auf, um keySelectionStrategy (SELECT_KEY_FROM_LIST oder USE_ANY_KEY) und alle bekannten bisherigen Signaturschlüssel (knownKeys) zu prüfen.
5. Android-Paketressource erstellen: Rufen Sie POST /v1/developerAccounts/{id}/androidPackages?androidPackageId={pkg} (CreateAndroidPackage) mit dem Text {"name": ""} auf. Dadurch wird die Ressource im Status DRAFT erstellt.
6. Fingerabdruck des App-Signaturschlüssels registrieren:Rufen Sie POST /v1/developerAccounts/{id}/androidPackages/{pkg}/keys (CreateAndroidPackageKey) mit dem JSON-Text {"certificateFingerprintSha256": "..."} auf. Prüfen Sie den zurückgegebenen Status:
   • DRAFT: Ein Nachweis der Eigentümerschaft des privaten Schlüssels ist erforderlich. Die Antwort enthält eine eindeutige verificationToken für Schritt 7.
   • IN_REVIEW: Der Nachweis der Eigentümerschaft und die Begründung werden automatisch übersprungen, z. B. wenn Sie einen neuen Paketnamen registrieren, der noch nie auf Android verwendet wurde, oder wenn Sie die Eigentümerschaft dieses Signaturschlüssels bereits für einen anderen Paketnamen in derselben DeveloperAccount bestätigt haben. Überspringen Sie Schritt 7 und den Aufruf zur Begründung in Schritt 8 und fahren Sie direkt mit dem Abrufen von GetAndroidPackage und GetAndroidPackageKey fort.
7. Bestätigungs-APK erstellen und hochladen (wenn der Status DRAFT ist): Betten Sie den zurückgegebenen verificationToken-String in assets/adi-registration.properties in einem minimalen APK ein, das packageName entspricht, signieren Sie es mit Ihrem privaten App-Signaturschlüssel und laden Sie es mit POST /upload/v1/developerAccounts/{id}/androidPackages/{pkg}/keys/{sha256}:verify (VerifyAndroidPackageKeyOwnership) hoch.
8. Begründung einreichen (falls erforderlich) und Registrierungsstatus abfragen: Wenn der Schlüssel den Status OWNERSHIP_VERIFIED hat und registrationJustificationRequired den Wert true hat, rufen Sie POST /v1/developerAccounts/{id}/androidPackages/{pkg}/keys/{sha256}:justifyAndroidPackageKeyRegistration (JustifyAndroidPackageKeyRegistration) auf. Fragen Sie GetAndroidPackage und GetAndroidPackageKey ab, bis state den Wert REGISTERED erreicht.

Lokale Befehlszeilenbefehle zum Vorbereiten von Schlüssel-Fingerabdrücken und Bestätigungs-APKs

• SHA-256-Zertifikat-Fingerabdruck aus einem Schlüsselspeicher (keytool) extrahieren:

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

• SHA-256-Signaturzertifikat-Digest für ein erstelltes APK (apksigner) prüfen:

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

• APK-Paketnamen und eingebettete Tokendatei vor dem Hochladen prüfen (aapt2 und unzip):

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

UI- und API-Funktionen der Android Developer Console

Aufgabe	Web-UI der Android Developer Console (android.google.com/developerconsole)	Android Developer Console API
Bestätigung der Entwickleridentität (KYC/KYB) und Zahlung der Gebühr	Unterstützt (einmalige Voraussetzung erforderlich)	Wird über die API nicht unterstützt (schreibgeschützte Statusprüfung mit GetDeveloperAccount und ListDeveloperAccounts)
Verknüpfte Entwicklerkonten ansehen	Kontoauswahl in der Kopfzeile der Console	GET /v1/developerAccounts (ListDeveloperAccounts)
Frühere Signaturschlüssel und Richtlinien für einen Paketnamen prüfen	Wird im Assistenten „Paketname registrieren“ angezeigt	GET /v1/.../registrationPolicy (GetAndroidPackageRegistrationPolicy)
Neuen Android-Paketnamen registrieren	Paketnamen > Paketname registrieren	POST /v1/{parent}/androidPackages?androidPackageId=... (CreateAndroidPackage)
Registrierte Paketnamen und Paketnamenentwürfe ansehen oder auflisten	Dashboard-Tabelle Paketnamen	GET /v1/{name} (GetAndroidPackage), GET /v1/{parent}/androidPackages (ListAndroidPackages)
App-Signaturschlüssel hinzufügen und Challenge-Token generieren	Paketdetails > Signierschlüssel hinzufügen	POST /v1/{parent}/keys (CreateAndroidPackageKey)
Inhaberschaft des privaten Schlüssels nachweisen (adi-registration.properties)	Signiertes Snippet-APK in der Console-Benutzeroberfläche hochladen	POST /upload/v1/{name}:verify (VerifyAndroidPackageKeyOwnership)
Begründung einreichen, wenn der Schlüssel manuell überprüft werden muss	Text-Prompt während des Workflows zur Schlüsselregistrierung	POST /v1/{name}:justifyAndroidPackageKeyRegistration (JustifyAndroidPackageKeyRegistration)

Dienstkonfiguration und Authentifizierung

Alle API-Anfragen müssen HTTPS verwenden und einen Authorization: Bearer ACCESS_TOKEN-Header enthalten, der über den OAuth 2.0-Webserverablauf für ein Google-Konto abgerufen wurde, für das die Identitätsüberprüfung als Entwickler in der Android Developer Console abgeschlossen wurde.

Attribut	Wert
Basis-REST-Endpunkt	https://androiddeveloperconsole.googleapis.com
Endpunkt für Medien-Uploads	https://androiddeveloperconsole.googleapis.com/upload
API-Version	v1
Erforderlicher OAuth 2.0-Bereich	https://www.googleapis.com/auth/androiddeveloperconsole
Standardkontingentlimit	2,000 Anfragen pro Tag, Google Cloud-Projekt und Methode

Hinweis: Für die Authentifizierung sind vom Nutzer delegierte OAuth 2.0-Anmeldedaten (Authorization: Bearer ACCESS_TOKEN) erforderlich. Dienstkonten, Workload Identity-Föderation und API-Schlüssel werden nicht unterstützt, da Android Developer Console-Konten direkt mit bestätigten Google-Konten von Nutzern verknüpft sind.

API-Ressourcen und -Endpunkte

Die Android Developer Console API organisiert Ressourcen in der folgenden Hierarchie:

• 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

Stellt ein Konto in der Android Developer Console dar, das mit einer Entwickleridentität verknüpft ist.

Feld	Typ	Beschreibung
name	string	ID. Ressourcenname im Format developerAccounts/{developer_account}.
displayName	string	Nur Ausgabe. Menschenlesbarer Name, der mit dem Entwicklerkonto verknüpft ist (Name einer natürlichen Person oder einer Organisation).
verificationState	enum (VerificationState)	Nur Ausgabe. Aktueller Status der Identitätsbestätigung des Entwicklers für das Konto.

Enum: DeveloperAccount.VerificationState

Wert	Beschreibung
VERIFIED	Die Identitätsüberprüfung des Entwicklers ist abgeschlossen. Über das Konto können Paketnamen und App-Signaturschlüssel registriert werden.
NOT_VERIFIED	Die Identitätsbestätigung des Entwicklers wurde in der Android Developer Console nicht abgeschlossen.

Methoden: DeveloperAccount

Methode	HTTP-Anfrage	Beschreibung
GetDeveloperAccount	GET /v1/{name=developerAccounts/*}	Ruft Metadaten und den Bestätigungsstatus für eine einzelne DeveloperAccount ab.
ListDeveloperAccounts	GET /v1/developerAccounts	Listet alle DeveloperAccount-Objekte auf, auf die das authentifizierte Google-Konto zugreifen kann (nicht paginiert).

Ressource: AndroidPackage

Stellt einen Android-Paketnamen dar, der unter einer DeveloperAccount registriert ist oder wird.

Feld	Typ	Beschreibung
name	string	ID. Ressourcenname im Format developerAccounts/{developer_account}/androidPackages/{android_package}, wobei {android_package} der Android-Paketname ist (z. B. com.example.myapp).
packageName	string	Nur Ausgabe. Der Android-Paketname (z. B. com.example.myapp).
state	enum (AndroidPackage.State)	Nur Ausgabe. Aktueller Lebenszyklusstatus der Registrierung des Paketnamens.
registeredAppStore	boolean	Nur Ausgabe. Gibt an, ob dieser Paketname derzeit als registrierter App-Shop aktiv ist.

Enum: AndroidPackage.State

Wert	Beschreibung
DRAFT	Die Paketnamenressource wurde erstellt und die Registrierung des App-Signaturschlüssels oder die Bestätigung der Inhaberschaft ist noch im Gange.
IN_REVIEW	Die Registrierung des Paketnamens und alle erforderlichen Begründungen für die Schlüssel wurden eingereicht und werden von Google überprüft. Ein Paket wechselt entweder sofort nach CreateAndroidPackageKey von DRAFT zu IN_REVIEW (wenn die Bestätigung der Schlüsselinhaberschaft übersprungen wird, einschließlich wenn der Schlüssel bereits für einen anderen Paketnamen in derselben DeveloperAccount bestätigt wurde) oder nach Abschluss von VerifyAndroidPackageKeyOwnership und, falls erforderlich, JustifyAndroidPackageKeyRegistration.
REGISTERED	Der Paketname ist für die Bestätigung für Android-Entwickler aktiv für dieses Entwicklerkonto registriert.
PENDING_TRANSFER	Die Übertragung der Eigentumsrechte für den Paketnamen auf ein anderes Entwicklerkonto steht noch aus.

Ressource: AndroidPackageRegistrationPolicy

Singleton-Ressource, die von GetAndroidPackageRegistrationPolicy zurückgegeben wird und die bisherigen öffentlichen Signaturschlüssel beschreibt, die für einen Paketnamen erkannt wurden, und angibt, ob für die Registrierung des Paketnamens mit einem bestimmten Signaturschlüssel eine schriftliche Begründung erforderlich ist.

Feld	Typ	Beschreibung
name	string	ID. Ressourcenname im Format developerAccounts/{developer_account}/androidPackages/{android_package}/registrationPolicy.
knownKeys[]	object (KnownKey)	Liste der bisherigen App-Signaturschlüssel, die zuvor für die Bereitstellung von Apps mit diesem Paketnamen verwendet wurden, lexikografisch nach certificateFingerprintSha256 sortiert.
knownKeys[].certificateFingerprintSha256	string	Nur Ausgabe. Normalisierter 64-stelliger hexadezimaler SHA-256-Fingerabdruck des bisherigen Signaturzertifikats in Kleinbuchstaben (ohne Doppelpunkte).
knownKeys[].justificationRequirement	enum (JustificationRequirement)	Nur Ausgabe. Gibt an, ob für die Registrierung dieses Schlüssels JustifyAndroidPackageKeyRegistration (REQUIRED oder NOT_REQUIRED) aufgerufen werden muss. Wenn der Signaturschlüssel zuvor für einen anderen Paketnamen unter derselben DeveloperAccount bestätigt wurde, werden sowohl VerifyAndroidPackageKeyOwnership als auch JustifyAndroidPackageKeyRegistration übersprungen, auch wenn justificationRequirement den Wert REQUIRED hat.
keySelectionStrategy	enum (KeySelectionStrategy)	Nur Ausgabe. Richtlinie für die Schlüsselauswahl zur Registrierung dieses Paketnamens: SELECT_KEY_FROM_LIST (ein Schlüssel von knownKeys muss registriert werden) oder USE_ANY_KEY (jeder gültige App-Signaturschlüssel des Entwicklers kann registriert werden).

Enum: KnownKey.JustificationRequirement

Wert	Beschreibung
REQUIRED	Wenn du diesen bekannten Schlüssel registrieren möchtest, musst du nach Abschluss von VerifyAndroidPackageKeyOwnership eine schriftliche Begründung über JustifyAndroidPackageKeyRegistration einreichen. Dies gilt nicht, wenn der Schlüssel zuvor für einen anderen Paketnamen unter derselben DeveloperAccount bestätigt wurde. In diesem Fall werden sowohl VerifyAndroidPackageKeyOwnership als auch JustifyAndroidPackageKeyRegistration übersprungen.
NOT_REQUIRED	Für die Registrierung dieses bekannten Schlüssels ist keine Begründung erforderlich. Der Schlüssel wechselt nach VerifyAndroidPackageKeyOwnership direkt zu IN_REVIEW (oder sofort nach CreateAndroidPackageKey, wenn der Schlüssel zuvor für einen anderen Paketnamen unter derselben DeveloperAccount bestätigt wurde).

Enum: AndroidPackageRegistrationPolicy.KeySelectionStrategy

Wert	Beschreibung
SELECT_KEY_FROM_LIST	Der Aufrufer muss einen der in knownKeys aufgeführten historischen Schlüssel registrieren.
USE_ANY_KEY	Zusätzlich zu den Schlüsseln in knownKeys kann der Aufrufer jeden gültigen App-Signaturschlüssel registrieren, der zuvor nicht im Android-Ökosystem beobachtet wurde.

Methoden: AndroidPackage

Methode	HTTP-Anfrage	Beschreibung
GetAndroidPackageRegistrationPolicy	GET /v1/{name=developerAccounts/*/androidPackages/*/registrationPolicy}	Ruft die Schlüsselauswahlstrategie und bekannte bisherige Signaturschlüssel für einen Paketnamen ab.
CreateAndroidPackage	POST /v1/{parent=developerAccounts/*}/androidPackages?androidPackageId={package_name}	Erstellt eine neue AndroidPackage-Ressource im Status DRAFT, um mit der Registrierung eines Paketnamens zu beginnen.
GetAndroidPackage	GET /v1/{name=developerAccounts/*/androidPackages/*}	Ruft Details und den aktuellen Registrierungsstatus für eine vorhandene AndroidPackage ab.
ListAndroidPackages	GET /v1/{parent=developerAccounts/*}/androidPackages	Listet AndroidPackage-Objekte unter einer DeveloperAccount auf (pageSize maximal 1000, pageToken).

Ressource: AndroidPackageKey

Stellt einen öffentlichen Zertifikat-Fingerabdruck für die App-Signatur dar, der mit einer AndroidPackage verknüpft ist, und verfolgt den Status der Inhaberschaftsbestätigung und der Registrierungsprüfung.

Feld	Typ	Beschreibung
name	string	ID. Vom Server zugewiesener Ressourcenname im Format developerAccounts/{developer_account}/androidPackages/{android_package}/keys/{key}, wobei {key} ein normalisierter 64-stelliger hexadezimaler SHA-256-Fingerabdruck in Kleinbuchstaben ohne Doppelpunkte ist. Muss beim Aufrufen von CreateAndroidPackageKey weggelassen werden oder leer sein.
certificateFingerprintSha256	string	Erforderlich. Nicht veränderbar. SHA-256-Hash des App-Signaturzertifikats. Bei der Eingabe in CreateAndroidPackageKey wird entweder ein einfacher 64-stelliger Hexadezimalwert (60e860e8...) oder ein durch Doppelpunkte getrennter Hexadezimalwert (60:E8:60:E8:...) akzeptiert. Bei der Ausgabe wird immer ein 64-stelliger Hexadezimalwert in Kleinbuchstaben ohne Doppelpunkte verwendet.
state	enum (AndroidPackageKey.State)	Nur Ausgabe. Aktueller Bestätigungs- und Registrierungslebenszyklusstatus des Schlüssels.
verificationToken	string	Nur Ausgabe. Eindeutiges Challenge-Token, das von Google generiert wurde. Wird nur verwendet, wenn der Status DRAFT ist. Kann ignoriert werden, wenn CreateAndroidPackageKey den Schlüssel direkt in IN_REVIEW überführt. Wenn der Status DRAFT ist, binde diesen String in assets/adi-registration.properties in ein signiertes APK ein, um VerifyAndroidPackageKeyOwnership abzuschließen.
registrationJustificationRequired	boolean	Nur Ausgabe. Wenn true und der Schlüssel den Status OWNERSHIP_VERIFIED hat, müssen Sie eine schriftliche Begründung über JustifyAndroidPackageKeyRegistration einreichen, bevor die Registrierung mit IN_REVIEW fortgesetzt wird. Wenn CreateAndroidPackageKey den Schlüssel direkt auf IN_REVIEW umstellt (weil der Schlüssel zuvor für einen anderen Paketnamen in derselben DeveloperAccount bestätigt wurde), wird die Begründung übersprungen.

Enum: AndroidPackageKey.State

Wert	Beschreibung
DRAFT	Die Schlüsselressource wurde erstellt. Der Nachweis des Besitzes des privaten Schlüssels durch Hochladen eines signierten APK (VerifyAndroidPackageKeyOwnership) ist weiterhin erforderlich, da die Inhaberschaft dieses Schlüssels noch für keinen Paketnamen unter dieser DeveloperAccount bestätigt wurde.
OWNERSHIP_VERIFIED	Die Inhaberschaft des privaten Schlüssels wurde durch den Upload eines signierten APKs bestätigt. Wenn registrationJustificationRequired den Wert true hat, ist vor Beginn der Überprüfung weiterhin eine Begründung erforderlich.
IN_REVIEW	Die Schlüsselregistrierung wird von Google überprüft. Ein Schlüssel wechselt hier entweder sofort nach CreateAndroidPackageKey, wenn kein Eigentumsnachweis erforderlich ist (z. B. bei einem neuen Paketnamen, der noch nie auf Android verwendet wurde, oder wenn der Schlüssel zuvor für einen anderen Paketnamen unter derselben DeveloperAccount bestätigt wurde, wodurch auch JustifyAndroidPackageKeyRegistration übersprungen wird), direkt nach VerifyAndroidPackageKeyOwnership (wenn registrationJustificationRequired false ist) oder nach JustifyAndroidPackageKeyRegistration (wenn registrationJustificationRequired true ist).
REGISTERED	Der App-Signaturschlüssel ist für die Bestätigung für Android-Entwickler aktiv für diesen Paketnamen registriert.
PENDING_TRANSFER	Die Registrierung des App-Signaturschlüssels wartet auf den Abschluss einer Übertragung.

Methoden: AndroidPackageKey

Methode	HTTP-Anfrage	Beschreibung
CreateAndroidPackageKey	POST /v1/{parent=developerAccounts/*/androidPackages/*}/keys	Registriert einen neuen SHA-256-Fingerabdruck des App-Signaturzertifikats unter einem AndroidPackage. Gibt den Schlüssel im Status DRAFT zurück (wenn ein Eigentumsnachweis mit VerifyAndroidPackageKeyOwnership erforderlich ist) oder direkt im Status IN_REVIEW (wenn die Bestätigung der Eigentümerschaft übersprungen wird, z. B. bei einem neuen Paketnamen, der noch nie auf Android verwendet wurde, oder bei einem Schlüssel, der bereits für einen anderen Paketnamen in derselben DeveloperAccount bestätigt wurde).
GetAndroidPackageKey	GET /v1/{name=developerAccounts/*/androidPackages/*/keys/*}	Ruft Status, Fingerabdruck und Bestätigungsmetadaten eines bestimmten AndroidPackageKey ab.
ListAndroidPackageKeys	GET /v1/{parent=developerAccounts/*/androidPackages/*}/keys	Listet alle AndroidPackageKey-Objekte auf, die unter einer AndroidPackage registriert sind (pageSize max. 1000, pageToken).
VerifyAndroidPackageKeyOwnership	POST /upload/v1/{name=developerAccounts/*/androidPackages/*/keys/*}:verify	Lädt ein signiertes minimales APK mit verificationToken in assets/adi-registration.properties hoch, um die Inhaberschaft des privaten Schlüssels zu bestätigen und fertige Schlüssel zur Überprüfung einzureichen.
JustifyAndroidPackageKeyRegistration	POST /v1/{name=developerAccounts/*/androidPackages/*/keys/*}:justifyAndroidPackageKeyRegistration	Sendet zusätzlichen Begründungskontext, wenn registrationJustificationRequired den Wert true hat, und sendet bestätigte Schlüssel zur Überprüfung.

Fehlerbehandlung

Wenn eine API-Anfrage fehlschlägt, gibt die Android Developer Console API den HTTP-Statuscode 4xx oder 5xx und einen standardmäßigen JSON-Fehlertext vom Typ google.rpc.Status zurück:

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

HTTP-Statuscodes und gängige Lösungen

HTTP-Code	gRPC-Status	Häufige Ursachen	Auflösung
400 Bad Request	INVALID_ARGUMENT	Fehlender oder ungültiger androidPackageId im Java-Stil; ungültiges certificateFingerprintSha256-Format; nicht leeres name-Feld in CreateAndroidPackage oder CreateAndroidPackageKey; hochgeladenes APK ist nicht signiert, beschädigt, enthält keinen assets/adi-registration.properties, enthält keinen übereinstimmenden verificationToken oder ist mit einem nicht übereinstimmenden Zertifikat signiert.	Validieren Sie die Anfrageformate anhand der Ressourcenschemas, lassen Sie name bei Erstellungsaufrufen weg oder lassen Sie es leer und überprüfen Sie vor dem Hochladen Ihre APK-Signatur und das eingebettete Token mit apksigner verify --print-certs und unzip -p app-release.apk assets/adi-registration.properties.
400 Bad Request	FAILED_PRECONDITION	DeveloperAccount hat verificationState: NOT_VERIFIED; die Schlüsselauswahl verstößt gegen AndroidPackageRegistrationPolicy (SELECT_KEY_FROM_LIST); VerifyAndroidPackageKeyOwnership oder JustifyAndroidPackageKeyRegistration wird in einem unzulässigen Zustand aufgerufen.	Schließen Sie die Identitätsbestätigung für Entwickler in der Android Developer Console ab, prüfen Sie zuerst GetAndroidPackageRegistrationPolicy und sehen Sie sich die aktuelle state der Ressource an.
401 Unauthorized	UNAUTHENTICATED	Fehlendes, abgelaufenes oder ungültiges OAuth 2.0-Bearer-Zugriffstoken oder Versuch, sich mit einem API-Schlüssel oder Dienstkonto zu authentifizieren.	Rufen Sie ein neues, vom Nutzer delegiertes OAuth 2.0-Bearer-Zugriffstoken mit dem Bereich https://www.googleapis.com/auth/androiddeveloperconsole ab.
403 Forbidden	PERMISSION_DENIED	Der authentifizierte Nutzer hat keine Berechtigung für das Ziel-DeveloperAccount oder die Ziel-AndroidPackage oder die Android Developer Console API ist im Google Cloud-Projekt nicht aktiviert.	Prüfen Sie die Kontomitgliedschaft mit ListDeveloperAccounts und achten Sie darauf, dass androiddeveloperconsole.googleapis.com in der Google Cloud Console aktiviert ist.
404 Not Found	NOT_FOUND	Der angegebene Ressourcenpfad DeveloperAccount, AndroidPackage oder AndroidPackageKey ist nicht vorhanden.	Bestätigen Sie die Ressourcenpfade mit ListDeveloperAccounts, ListAndroidPackages oder ListAndroidPackageKeys. Achten Sie darauf, dass {key}-IDs Kleinbuchstaben im Hexadezimalformat ohne Doppelpunkte verwenden.
409 Conflict	ALREADY_EXISTS	Der Paketname oder der SHA-256-Zertifikat-Fingerabdruck ist bereits in diesem oder einem anderen Entwicklerkonto registriert.	Prüfen Sie vorhandene Registrierungen mit GetAndroidPackage oder GetAndroidPackageKey oder die bisherige Inhaberschaft mit GetAndroidPackageRegistrationPolicy.
429 Too Many Requests	RESOURCE_EXHAUSTED	Das Kontingent von 2,000 Anfragen pro Tag und Google Cloud-Projekt wurde überschritten.	Implementieren Sie exponentiellen Backoff mit Jitter und vermeiden Sie hochfrequente Abfrageschleifen.
500/503	INTERNAL/UNAVAILABLE	Vorübergehender Backend-Fehler oder vorübergehende Nichtverfügbarkeit des Dienstes.	Wiederholen Sie idempotente Anfragen mit abgeschnittenem exponentiellem Backoff.

Beispiele für HTTP-Anfragen und -Antworten

Ersetzen Sie Platzhalterwerte wie ACCESS_TOKEN, 1234567890, com.example.myapp und 60e860e8... durch Ihre eigenen Werte.

1. GetDeveloperAccount

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

Antwort

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

2. ListDeveloperAccounts

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

Antwort

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

Antwort

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

Antwort

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

Antwort

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

Antwort

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

Antwort

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

Hinweis: state ist DRAFT, wenn ein Nachweis des Eigentums am privaten Schlüssel erforderlich ist. Wenn keine Bestätigung der Inhaberschaft erforderlich ist (z. B. bei der Registrierung eines neuen Paketnamens, der noch nie auf Android verwendet wurde, oder wenn dieser Schlüssel bereits für einen anderen Paketnamen unter derselben DeveloperAccount bestätigt wurde), gibt CreateAndroidPackageKey den Status IN_REVIEW zurück und stellt den Schlüssel automatisch zur Überprüfung in die Warteschlange. Rufe in diesem Fall nicht VerifyAndroidPackageKeyOwnership (Beispiel 10) oder JustifyAndroidPackageKeyRegistration (Beispiel 11) auf.

8. GetAndroidPackageKey

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

Antwort

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

Antwort

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

10. VerifyAndroidPackageKeyOwnership

Option A: Medienupload mit einer einzigen Anfrage

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: Protokoll für fortsetzbare Uploads (empfohlen für große APKs oder CI/CD)

Schritt 1: Starten Sie die fortsetzbare Uploadsitzung und extrahieren Sie den zurückgegebenen X-Goog-Upload-URL-Header:

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

Schritt 2: Laden Sie die signierte APK-Binärdatei in UPLOAD_SESSION_URI hoch und schließen Sie die Sitzung ab:

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"

Antwort

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

Antwort

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

Zusätzliche Ressourcen

• Paketnamen mit der Android Developer Console API registrieren
• App-Registrierungsstatus mit der Android Developer ID Status API prüfen
• In der Android Developer Console registrieren
• In der Google Play Console registrieren