Ersten Google Health API-Aufruf senden

1. Einführung

Mit Visual Studio Code (VS Code) und der Rest Client-Erweiterung von Huachao Mao können Sie den Google-OAuth-Zustimmungsablauf und die Google Health API testen. In diesem Codelab erfahren Sie, wie Sie die Rest Client-Erweiterung einrichten, den Autorisierungsablauf starten und Ihren ersten Aufruf an einen der Google Health API-Endpunkte senden. Anschließend können Sie die Rest Client-Dokumentation und die Fitbit-Dokumentation lesen, um die anderen Endpunkte in Ihrem HTTP-Projekt zu erstellen.

Wenn Sie VS Code und den REST-Client nicht verwenden möchten, können die API-Aufrufe mit curl-Befehlen ausgeführt werden.

Lerninhalte

• VS Code mit der Rest Client-Erweiterung einrichten
• So richten Sie eine Client-ID in der Google Cloud Console ein.
• So durchlaufen Sie den Google OAuth 2.0-Autorisierungsvorgang, um ein Zugriffs- und ein Aktualisierungstoken zu erhalten.
• Hier erfahren Sie, wie Sie Google Health API-Endpunkte mit einem REST-Client aufrufen.

Voraussetzungen

• Fitbit App
• Visual Studio Code
• Rest Client-Erweiterung von Huacho Mao.

So richtest du die Fitbit App ein:

1. Suche im Apple App Store oder Google Play Store nach der mobilen Fitbit App und lade sie herunter.
2. Wählen Sie das App-Symbol aus.
3. Klicken Sie auf Über Google anmelden.
4. Wählen Sie Ihr Google-Konto aus und drücken Sie die Schaltfläche Weiter.

So installieren Sie die Visual Studio-Tools:

1. Laden Sie VS Code herunter. Normalerweise enthält der Download die ausführbare Datei.
2. Starten Sie VS Code.
3. Installieren Sie die Rest Client-Erweiterung von Huachao Mao.
   • Klicken Sie links in der IDE auf das Erweiterungssymbol .
   • Suchen Sie nach REST Client by Huachao Mao und klicken Sie auf Installieren.

Hinweis:Wenn Sie die Erweiterung zum ersten Mal verwenden, wird in VS Code möglicherweise angezeigt, dass sie nicht vertrauenswürdig ist, oder Sie werden aufgefordert, den Arbeitsbereich oder die Erweiterung als vertrauenswürdig einzustufen. Dies ist eine standardmäßige VS Code-Sicherheitsfunktion für Drittanbietererweiterungen. Damit die Rest Client-Erweiterung in diesem Codelab richtig funktioniert, müssen Sie ihr vertrauen.

2. Google Cloud-Projekt einrichten

Sie verwenden die Google Cloud Console, um eine Client-ID zu erstellen und die Verwendung der Google Health API zu aktivieren.

1. Melden Sie sich in der Google Cloud Console an.
2. So erstellen Sie ein neues Projekt:
   1. Klicken Sie in der Projektauswahl auf Projekt auswählen.
   2. Wählen Sie oben rechts Neues Projekt aus.
   3. Geben Sie den Projektnamen ein.
   4. Geben Sie den Standort ein (z. B. „Keine Organisation“).
   5. Klicken Sie auf Erstellen.
   6. Wählen Sie Ihr Projekt aus.

Google Health API aktivieren

1. Klicken Sie links oben auf das Dreistrich-Menü .
2. Wählen Sie APIs & Dienste > Bibliothek aus.
3. Suchen Sie nach „Google Health API“ und aktivieren Sie sie.

OAuth-Anmeldedaten einrichten

Wenn Sie sich nicht in der Google Cloud Console befinden, rufen Sie die Google Cloud Console auf.

1. Klicken Sie links oben auf das Dreistrich-Menü .
2. Wählen Sie APIs & Dienste > Anmeldedaten aus.
3. Wählen Sie oben in der Mitte + Anmeldedaten erstellen > OAuth-Client-ID aus.
4. Klicken Sie auf die Schaltfläche Zustimmungsbildschirm konfigurieren. Wenn die Meldung „Google Auth Platform noch nicht konfiguriert“ angezeigt wird, klicken Sie auf die Schaltfläche Jetzt starten.
5. Abschnitt 1:
   1. Geben Sie einen Namen unter App-Name ein.
   2. Geben Sie die E‑Mail-Adresse für den Nutzersupport ein.
   3. Klicken Sie auf die Schaltfläche Weiter.
6. In Abschnitt 2:
   1. Wählen Sie Extern aus.
   2. Klicken Sie auf die Schaltfläche Weiter.
7. In Abschnitt 3:
   1. Geben Sie Ihre E-Mail-Adresse in das Feld Kontaktdaten ein.
   2. Klicken Sie auf die Schaltfläche Weiter.
8. In Abschnitt 4:
   1. Klicken Sie auf das Kästchen, um der Nutzerdatenrichtlinie für Google API-Dienste zuzustimmen.
   2. Klicken Sie auf Erstellen.
9. Klicken Sie im Bereich „Messwerte“ auf die Schaltfläche OAuth-Client erstellen.
10. Wählen Sie den Anwendungstyp Webanwendung aus.
11. Geben Sie den Namen der Client-ID ein.
12. Lassen Sie das Feld Autorisierte JavaScript-Quellen leer.
13. Klicken Sie unter Autorisierte Weiterleitungs-URIs auf die Schaltfläche + URI hinzufügen. Geben Sie „https://www.google.com“ als Weiterleitungs-URI ein.
14. Klicken Sie auf Erstellen.
15. In der Google Console wird eine Meldung angezeigt, dass Ihre Client-ID erstellt wurde. Klicken Sie entweder auf den Link JSON herunterladen, um die Client-ID und den Clientschlüssel herunterzuladen, oder notieren Sie sich die Werte. Sie können das Clientgeheimnis Ihres Kunden danach nicht mehr wiederherstellen.
16. Klicken Sie auf OK. Sie kehren zur Seite „OAuth 2.0-Client-IDs“ zurück.
17. Ihre Client-ID wird Ihrem Projekt hinzugefügt. Klicken Sie auf die Client-ID-URL, um die Details aufzurufen.

Hinweis: Wenn Sie Ihren Clientschlüssel nicht heruntergeladen oder gespeichert haben, müssen Sie einen neuen erstellen, da Sie ihn nicht noch einmal aufrufen können. Klicken Sie auf OK und wählen Sie auf der Seite Anmeldedaten unter OAuth 2.0-Client-IDs Ihre Client-ID aus. Rufen Sie den Bereich Clientschlüssel auf und wählen Sie + SCHLÜSSEL HINZUFÜGEN aus. Ein neuer Clientschlüssel wird generiert, den Sie herunterladen oder speichern müssen. Aus Sicherheitsgründen sollten Sie alle Clientschlüssel löschen, die nicht mehr verwendet werden. Klicken Sie dazu auf das Löschsymbol.

Testnutzer hinzufügen

1. Wählen Sie im linken Bereich Zielgruppe aus. Der „Veröffentlichungsstatus“ sollte auf Testen und der „Nutzertyp“ auf Extern festgelegt sein.
2. Klicken Sie im Bereich „Testnutzer“ auf die Schaltfläche + Nutzer hinzufügen. Geben Sie die E‑Mail-Adresse aller Nutzer ein, deren Daten Sie abrufen möchten.
3. Klicken Sie auf Speichern.

Bereiche zur Client-ID hinzufügen

1. Wählen Sie im linken Bereich Datenzugriff aus.
2. Klicken Sie auf die Schaltfläche Bereiche hinzufügen oder entfernen.
3. Suchen Sie in der Spalte „API“ nach „Google Health API“. In diesem Codelab verwenden wir den Bereich .../auth/googlehealth.activity_and_fitness.readonly.
4. Nachdem Sie den Bereich ausgewählt haben, drücken Sie die Schaltfläche Aktualisieren, um zur Seite „Datenzugriff“ zurückzukehren.
5. Klicken Sie auf Speichern.

Sie haben die Einrichtung Ihrer Client-ID abgeschlossen.

3. Autorisierungsablauf erstellen

1. Öffnen Sie die VS Code App auf Ihrem Computer.
2. Wählen Sie auf dem Begrüßungsbildschirm Öffnen aus.
3. Wählen Sie einen Ordner aus, in dem Sie das Projekt erstellen möchten, und klicken Sie auf Öffnen. Ihr Bildschirm sollte in etwa so aussehen und den Namen Ihres Ordners oder Projekts im Explorer anzeigen.
4. Wählen Sie im Hauptmenü Datei -> Neue Textdatei aus.
5. Speichern Sie die Datei, um ihr einen Namen zu geben. Wählen Sie im Hauptmenü Datei -> Speichern unter -> Codelab.http aus. Dadurch sollte die Datei in Ihrem Projekt platziert werden. Die Dateiendung muss entweder „.http“ oder „.rest“ sein. In diesem Codelab verwenden wir .http.

In diesem Projekt werden wir mehrere Werte mehrmals verwenden. Diese Werte sind:

client_id	Der Wert der Client-ID aus der Google Console.
secret	Der Clientschlüsselwert aus der Google-Konsole.
redirect_uri	Ein Endpunkt in Ihrer App, der den Autorisierungscode verarbeitet. Für das Codelab verwenden wir https://www.google.com.
access_token	Das Zugriffstoken, das für den Nutzer erstellt wurde, nachdem der Einwilligungsablauf abgeschlossen ist.
refresh_token	Das Aktualisierungstoken, das für den Nutzer erstellt wurde, nachdem der Einwilligungsablauf abgeschlossen ist.

Fügen Sie den folgenden Code hinzu, der die für dieses Projekt verwendeten Variablen definiert. Sie sollten sich oben in der Datei „Codelab.http“ befinden. Geben Sie die Werte für „client_id“ und „secret“ ein.

### File Variables for the Codelab
@client_id =
@secret =
@redirect_uri = https://www.google.com
@accessToken={{user.response.body.access_token}}
@refreshToken={{user.response.body.refresh_token}}

Die Autorisierungs-URL, mit der der Einwilligungsablauf gestartet wird, wird an jeden Nutzer gesendet, auf dessen Daten Sie zugreifen möchten. Um die Autorisierungs-URL zu erstellen, müssen wir wissen, wie der Google OAuth-Endpunkt lautet. Außerdem müssen wir die Client-ID, die Bereiche, auf die wir zugreifen möchten, und die Weiterleitungs-URL angeben, an die der Nutzer weitergeleitet wird, wenn er den Bereichen zustimmt. Die vollständige Dokumentation zum Erstellen des Google-Autorisierungsstrings finden Sie in der Dokumentation.

Der OAuth 2.0-Endpunkt von Google ist https://accounts.google.com/o/oauth2/v2/auth. Dieser Endpunkt ist nur über HTTPS zugänglich. Reine HTTP-Verbindungen werden abgelehnt.

Der Google-Autorisierungsserver unterstützt viele Abfragestringparameter für Webserveranwendungen, um den Autorisierungsablauf anzupassen. Wir verwenden die folgenden erforderlichen Abfrageparameter: client_id, redirect_uri, response_type und scope. In der Dokumentation finden Sie eine Liste aller Abfrageparameter und deren Beschreibung.

Die Werte für die Abfrageparameter sind

client_id	Der Wert der Client-ID aus der Google Console
redirect_uri	Ein Endpunkt in Ihrer App, der den Autorisierungscode verarbeitet. Verwenden Sie für das Codelab https://www.google.com.
response_type	code (unterstützter Wert für Web-Apps)
scope	Die Bereiche stammen aus der Google-Konsole mit der Syntax https://www.googleapis.com gefolgt vom Bereichsnamen. Beispiel: https://www.googleapis.com/auth/googlehealth.activity_and_fitness. Wenn Sie mehrere Bereiche anfordern möchten, geben Sie alle Bereiche im Parameter „scope“ an und trennen Sie sie durch Leerzeichen (z. B. scope1 scope2 scope3). Wenn Leerzeichen Teil der URL sind, müssen sie URL-codiert werden (z. B. %20).

Schreiben Sie nach den Variablen unsere Autorisierungs-URL wie unten gezeigt. Die oben im Projekt definierten Parameter können nicht im Autorisierungsstring verwendet werden. Daher müssen wir die Werte für client_id und redirect_uri einbeziehen. Ersetzen Sie den String client-id durch Ihre Client-ID.

### Google Health API Rest Client Example

### Authorization String
https://accounts.google.com/o/oauth2/v2/auth?client_id=client-id&redirect_uri=https://www.google.com&response_type=code&access_type=offline&scope=https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly

Wenn ein Nutzer die Einwilligung erteilt, stellt Google einen Autorisierungscode bereit, den Sie durch Aufrufen des Google-Tokenendpunkts gegen ein Zugriffstoken eintauschen. Fügen Sie die folgende Definition für den Aufruf des Token-Endpunkts in Codelab.http unter dem Autorisierungsstring hinzu. Im nächsten Schritt ersetzen Sie authorization-code durch einen Autorisierungscode.

### AUTHORIZATION ENDPOINTS
######################################################################
# @name user
POST https://oauth2.googleapis.com/token
Content-Type: application/x-www-form-urlencoded

code=authorization-code&client_id={{clientId}}&client_secret={{secret}}&redirect_uri={{redirect_uri}}&grant_type=authorization_code

@name user bezieht sich auf den aktuellen Nutzer, dessen Daten Sie aufrufen.

4. Konto autorisieren und Tokens abrufen

Als Nächstes sehen wir uns den Autorisierungsablauf an, um Autorisierungstokens zu erhalten.

Mit dem Autorisierungsstring in Codelab.http wird der browserbasierte Einwilligungsablauf von Google initiiert. Die Rest Client-Erweiterung zeigt möglicherweise den Link Send Request (Anfrage senden) für diese URL an. Verwenden Sie für diese spezielle URL nicht Anfrage senden. Kopieren Sie ihn stattdessen und fügen Sie ihn in Ihren Browser ein oder verwenden Sie Strg+Klick (Windows/Linux) oder Cmd+Klick (Mac) in VS Code, um ihn in Ihrem Standardbrowser zu öffnen.

https://accounts.google.com/o/oauth2/v2/auth?client_id=client-id&redirect_uri=https://www.google.com&response_type=code&access_type=offline&scope=https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly

1. Sie werden aufgefordert, sich in Ihrem Google-Konto anzumelden. Sie müssen sich mit einem der Testnutzerkonten anmelden, die Sie im Abschnitt Testnutzer hinzufügen konfiguriert haben.
2. Möglicherweise wird eine Meldung angezeigt, die besagt, dass die App nicht überprüft wurde. Das liegt daran, dass die App nicht veröffentlicht wurde. Tippen Sie auf „Weiter“.

1. Auf der Einwilligungsseite werden die angeforderten Bereiche aufgeführt. Der Nutzer hat die Möglichkeit, die Bereiche auszuwählen, die er für diese App freigeben möchte. Klicken Sie auf „Weiter“.

Nachdem Sie der Freigabe der angeforderten Bereiche zugestimmt haben, werden Sie zur von Ihnen angegebenen redirect_uri weitergeleitet (in diesem Codelab: https://www.google.com). Google hängt der redirect_uri einen Autorisierungscode und andere Parameter an. Die URL in der Adresszeile Ihres Browsers sollte also in etwa so aussehen:

https://www.google.com/?code=4/0Ab32j93oyGWqaXE112sP1IKmh3kV1fE4tcHIMXYJQYWgNEtAa_0-YsfkS9Ekj3Be89u3fw&scope=https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly

Der Autorisierungscode ist der alphanumerische Wert zwischen „code=“ und „&scope“. Im obigen Beispiel ist der Wert:

4/0Ab32j93oyGWqaXE112sP1IKmh3kV1fE4tcHIMXYJQYWgNEtAa_0-YsfkS9Ekj3Be89u3fw

In einer Produktionsanwendung würde Ihr Server dies aus den URL-Parametern parsen. Kopieren Sie für dieses Codelab den Autorisierungscode aus der URL in Ihrem Browser.

Tauschen Sie diesen Autorisierungscode jetzt gegen ein access_token und ein refresh_token ein. Ersetzen Sie in Codelab.http authorization-code im POST-Anfragetext /token durch den kopierten Autorisierungscode.

POST https://oauth2.googleapis.com/token
Content-Type: application/x-www-form-urlencoded

code=authorization-code&client_id={{client_id}}&client_secret={{secret}}&redirect_uri={{redirect_uri}}&grant_type=authorization_code

Klicken Sie direkt über der Zeile POST https://oauth2.googleapis.com/token auf den Link Anfrage senden.

Die Antwort sollte in etwa so aussehen:

{
  "access_token": "ya29.a0ATi6K2uasci7FyyIClNLtQou6z...",
  "expires_in": 3599,
  "refresh_token": "1//05EuqYpEXjJCHCgYIA...",
  "scope": "https://www.googleapis.com/auth/googlehealth.activity_and_fitness",
  "token_type": "Bearer",
  "refresh_token_expires_in": 604799
}

Wenn Sie diese Antwort erhalten, werden die oben in Codelab.http definierten Variablen @accessToken und @refreshToken automatisch vom Rest Client für nachfolgende Anfragen verwendet.

Hinweis:Die Tokens werden nur in dieser Sitzung gespeichert. Wenn Sie das VS Code-Fenster schließen, müssen Sie den Autorisierungsvorgang noch einmal durchführen.

Aktualisierungstokens

Wenn Sie den Autorisierungscode austauschen, kann die Antwort zusätzlich zum access_token auch ein refresh_token enthalten. access_tokens sind kurzlebig (in der Regel 1 Stunde). Wenn ein access_token abläuft, müssen Sie das refresh_token verwenden, um ein neues access_token abzurufen, ohne dass sich der Nutzer noch einmal anmelden oder seine Einwilligung geben muss. Das ist möglich, weil wir access_type=offline in unsere Autorisierungsanfrage aufgenommen haben.

Wenn Sie in der Antwort kein refresh_token erhalten, haben Sie möglicherweise bereits die Einwilligung für diese App und die entsprechenden Bereiche erteilt. Aktualisierungstokens werden in der Regel nur beim ersten Mal ausgestellt, wenn ein Nutzer die Einwilligung für Ihre App erteilt, oder wenn prompt=consent der Autorisierungs-URL hinzugefügt wird, damit der Einwilligungsbildschirm auch bei nachfolgenden Autorisierungen angezeigt wird.

Das refresh_token ist langlebig, kann aber ablaufen oder ungültig werden, wenn es sechs Monate lang nicht verwendet wird, wenn der Nutzer den Zugriff auf Ihre App widerruft oder aus anderen Gründen. Bewahren Sie refresh_token für die zukünftige Verwendung an einem sicheren Ort auf.

Weitere Informationen finden Sie unter Zugriffstoken aktualisieren (Offlinezugriff).

5. Daten in der Fitbit App hinzufügen

Wenn Sie ein neuer Fitbit-Nutzer sind, haben Sie möglicherweise noch keine Daten in Ihrem Fitbit-Konto, die Sie abfragen können. Wir fügen manuell einen Trainingslog hinzu, den wir über einen der Endpunkte abfragen können. So zeichnest du ein Training manuell auf:

1. Öffne die Fitbit App auf deinem Gerät. Melde dich bei Bedarf in deinem Fitbit-Konto an.
2. Tippen Sie rechts unten auf dem Bildschirm auf die Schaltfläche +.
3. Tippe im Bereich „Manuell aufzeichnen“ auf Aktivität.
4. Suche nach dem Trainingstyp Gehen und wähle ihn aus.
5. Geben Sie eine Startzeit für heute ein.
6. Ändern Sie die Dauer in 15 Minuten.
7. Lassen Sie die Entfernung auf 1,0 Meilen.
8. Tippen Sie auf Hinzufügen.
9. Synchronisiere die mobile App mit den Fitbit-Servern, indem du lange auf das Display drückst und es nach unten schiebst. Wenn Sie den Finger loslassen, sollte die mobile App synchronisiert werden.
10. Im Bereich „Aktivität“ sollte der manuell protokollierte Eintrag für den Lauf angezeigt werden.

6. Daten mit der Methode „list“ abrufen

Um die Methode list aufzurufen, fügen Sie den folgenden Code in Codelab.http direkt unter dem Endpunkt /token ein.

### users.dataTypes.dataPoints
#####################################################

### LIST exercise
GET https://health.googleapis.com/v4/users/me/dataTypes/exercise/dataPoints
Authorization: Bearer {{accessToken}}
Accept: application/json

Mit diesem Code wird der list-Endpunkt aufgerufen, um die Schritte anzuzeigen, die der Nutzer in seinem Fitbit-Konto aufgezeichnet hat. Die Schrittzahl für jede Minute wird in der Antwort zurückgegeben, ähnlich wie beim Endpunkt „Activity Intraday“ der Fitbit Web API v1.

Klicken Sie zum Ausführen des Aufrufs für den GET-Endpunkt auf den Link Send Request (Anfrage senden). Die Antwort sollte in etwa so aussehen:

{
  "dataPoints": [
    {
      "name": "users/2515055256096816351/dataTypes/exercise/dataPoints/8896720705097069096",
      "dataSource": {
        "recordingMethod": "MANUAL",
        "platform": "FITBIT"
      },
      "exercise": {
        "interval": {
          "startTime": "2026-02-23T13:10:00Z",
          "startUtcOffset": "-18000s",
          "endTime": "2026-02-23T13:25:00Z",
          "endUtcOffset": "-18000s"
        },
        "exerciseType": "WALKING",
        "metricsSummary": {
          "caloriesKcal": 16,
          "distanceMillimiters": 1609344,
          "steps": "2038",
          "averagePaceSecondsPerMeter": 0.55923407301360051,
          "activeZoneMinutes": "0"
        },
        "exerciseMetadata": {},
        "displayName": "Walk",
        "activeDuration": "900s",
        "exerciseEvents": [
          {
            "eventTime": "2026-02-23T13:10:00Z",
            "eventUtcOffset": "-18000s",
            "exerciseEventType": "START"
          },
          {
            "eventTime": "2026-02-23T13:25:00Z",
            "eventUtcOffset": "-18000s",
            "exerciseEventType": "STOP"
          }
        ],
        "updateTime": "2026-02-24T01:19:22.450466Z"
      }
    },
    {
      "name": "users/2515055256096816351/dataTypes/exercise/dataPoints/5870930690409355408",
      "dataSource": {
        "recordingMethod": "MANUAL",
        "platform": "FITBIT"
      },
      "exercise": {
        "interval": {
          "startTime": "2026-02-23T06:00:00Z",
          "startUtcOffset": "-18000s",
          "endTime": "2026-02-23T06:15:00Z",
          "endUtcOffset": "-18000s"
        },
        "exerciseType": "WALKING",
        "metricsSummary": {
          "caloriesKcal": 17,
          "distanceMillimiters": 1609344,
          "steps": "2038",
          "averagePaceSecondsPerMeter": 0.55923407301360051,
          "averageHeartRateBeatsPerMinute": "81",
          "activeZoneMinutes": "0",
          "heartRateZoneDurations": {
            "lightTime": "900s"
          }
        },
        "exerciseMetadata": {},
        "displayName": "Walk",
        "activeDuration": "900s",
        "exerciseEvents": [
          {
            "eventTime": "2026-02-23T06:00:00Z",
            "eventUtcOffset": "-18000s",
            "exerciseEventType": "START"
          },
          {
            "eventTime": "2026-02-23T06:15:00Z",
            "eventUtcOffset": "-18000s",
            "exerciseEventType": "STOP"
          }
        ],
        "updateTime": "2026-02-23T08:29:39.480437Z"
      }
    }
  ],
  "nextPageToken": ""
}

Viele Endpunkte unterstützen Abfrageparameter zum Filtern oder für die Paginierung. Für Training wird beispielsweise der Filter interval.civil_start_time unterstützt. Fügen Sie Codelab.http die folgende Anfrage hinzu, um Übungen in einem bestimmten Zeitraum aufzulisten:

### LIST exercise >= civil start time
GET https://health.googleapis.com/v4/users/me/dataTypes/exercise/dataPoints?filter=exercise.interval.civil_start_time >= "2026-02-22T00:00:00"
Authorization: Bearer {{accessToken}}
Accept: application/json

7. Glückwunsch

Glückwunsch!

Sie haben das grundlegende Codelab abgeschlossen und gelernt, wie Sie Visual Studio Code und die Rest Client-Erweiterung verwenden, um die OAuth 2.0-Autorisierung zu testen und Aufrufe an Google Health API-Endpunkte zu senden. Von hier aus können Sie die zusätzlichen Endpunkte genauso hinzufügen wie am Anfang des Abschnitts Daten mit der List-Methode abrufen.

Wir hoffen, dass Sie viel Freude beim Entwickeln von Apps haben, die in das Google Health API-Ökosystem eingebunden werden. Weitere Informationen finden Sie in der Referenzdokumentation zu anderen Google Health API-Endpunkten und unter OAuth 2.0 für Webserveranwendungen.