Client libraries

This page provides client library examples for accessing the Google Health API.

The Google Health API is built on HTTP and JSON, so any standard HTTP client can send requests to it and parse the responses.

However, instead of creating HTTP requests and parsing responses manually, you may want to use the client library examples and downloads featured here.

Java

  1. Add the Google API Client Library:
    • Include the library in your project (using Maven or Gradle).
  2. Implement OAuth 2.0 Flow:
    • Use the google-auth-library-java to handle the OAuth flow.
  3. Make API Requests:
    • Use the initialized client to make requests to the Google Health API.
import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow;
import com.google.api.client.googleapis.auth.oauth2.GoogleClientSecrets;
import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.client.util.store.FileDataStoreFactory;
import com.google.api.services.health.v1.Health; // Assuming a generated Google Health API client
import com.google.api.services.health.v1.model.DataResponse; // Example: Response model
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.GeneralSecurityException;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Scanner;

public class GoogleHealthApiExample {

    private static final String CLIENT_SECRETS_PATH = "path/to/your/client_secret.json";
    private static final String TOKENS_DIRECTORY_PATH = "tokens";
    private static final String API_KEY = "YOUR_API_KEY";
    private static final List<String> SCOPES = Collections.singletonList("https://www.googleapis.com/auth/health");
    private static final String APPLICATION_NAME = "Google Health API Example";
    private static final String DISCOVERY_URL = "https://health.googleapis.com/$discovery/rest"; // Adjust if needed

    private static final JsonFactory JSON_FACTORY = new GsonFactory();
    private static FileDataStoreFactory dataStoreFactory;
    private static HttpTransport httpTransport;

    static {
        try {
            httpTransport = GoogleNetHttpTransport.newTrustedTransport();
            dataStoreFactory = new FileDataStoreFactory(new File(TOKENS_DIRECTORY_PATH));
        } catch (GeneralSecurityException | IOException e) {
            throw new RuntimeException("Error initializing HttpTransport or DataStoreFactory", e);
        }
    }


    public static void main(String[] args) {
        try {
             Health healthService = createHealthService();
             fetchHealthData(healthService);
        } catch (Exception e) {
            System.err.println("Error during execution: " + e.getMessage());
             e.printStackTrace();
        }
    }

    private static Health createHealthService() throws IOException {
        Credential credential = getCredentials();
        return new Health.Builder(httpTransport, JSON_FACTORY, credential)
                .setApplicationName(APPLICATION_NAME)
                .setGoogleClientRequestInitializer(request -> {
                    request.set("key", API_KEY);
                })
                .setRootUrl(DISCOVERY_URL)
                .build();
    }

    private static Credential getCredentials() throws IOException {
        // Load client secrets
        InputStream in = Objects.requireNonNull(GoogleHealthApiExample.class.getClassLoader().getResourceAsStream(CLIENT_SECRETS_PATH),
                "client_secret.json not found");
        GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(JSON_FACTORY, new InputStreamReader(in));

        // Build flow and trigger user authorization request.
        GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(
                httpTransport, JSON_FACTORY, clientSecrets, SCOPES)
                .setDataStoreFactory(dataStoreFactory)
                .setAccessType("offline") // Allows for refresh tokens
                .build();

        Credential credential = flow.loadCredential("user"); // "user" is a key for storing/loading credentials.
        if (credential == null || !credential.getAccessToken() != null && credential.getExpiresInSeconds() <= 60) {
            // Prompt user to authorize and get new credentials
            System.out.println("Please open the following URL in your browser and authorize the app:");
            System.out.println(flow.newAuthorizationUrl().setRedirectUri("urn:ietf:wg:oauth:2.0:oob").build());
            System.out.print("Enter the authorization code: ");
            String code = new Scanner(System.in).nextLine();
            credential = flow.createAndStoreCredential(
                    flow.newTokenRequest(code).setRedirectUri("urn:ietf:wg:oauth:2.0:oob").execute(), "user"
            );
        }
        return credential;
    }

    private static void fetchHealthData(Health client) throws IOException {
        try {
            // Example: Replace with actual API method calls
            Health.Users.Data.List request = client.users().data().list();
            DataResponse response = request.execute();
            System.out.println("Health data: " + response);
        } catch (Exception e) {
            System.err.println("Error fetching health data: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

  // Process the response
  if (response.statusCode() == 200) {
      System.out.println("API Response: " + response.body());
  } else {
      System.err.println("Error: " + response.statusCode() + " " + response.body());
}
  • Import Libraries:
    • com.google.api.client.*: Core libraries for Google API client.
    • com.google.api.services.health.*: Generated classes for the Google Health API. (You'll need to generate this based on the API's discovery document).
  • Configuration:
    • CLIENT_SECRETS_PATH: Path to your client_secret.json file.
    • TOKENS_DIRECTORY_PATH: Path to store the tokens.
    • API_KEY: Your API key.
    • SCOPES: The required permissions.
    • DISCOVERY_URL: URL to get the API definition.
  • main Method:
    • Initializes the Google Health API client and calls fetchHealthData.
  • createHealthService():
    • Creates an instance of the Google Health API client, setting credentials, app name, and API key.
  • getCredentials():
    • Loads client secrets from file.
    • Creates a GoogleAuthorizationCodeFlow.
    • Attempts to load stored credentials.
    • If no credentials or expired credentials are found, prompts the user for authorization code, and stores the new credentials.
    • Returns the credentials object.
  • fetchHealthData():
    • Makes an API call to the Google Health API (replace the example with your specific method calls).
    • Prints the response.
  • Error Handling: The code includes basic try...catch blocks for error handling.

JavaScript

  1. Install the Google API Client Library:
    • Include the library in your project. You can use a CDN or npm.
  2. Implement OAuth 2.0 Flow:
    • Use the Google Identity Services library to handle the OAuth flow (result 16.1).
  3. Make API Requests:
    • Use the initialized client to make requests to the Google Health API.
  import { google } from 'https://apis.google.com/js/api.js';
  import { GoogleIdentityServices } from 'https://accounts.google.com/gsi/client';

  const CLIENT_ID = 'YOUR_CLIENT_ID';
  const API_KEY = 'YOUR_API_KEY';
  const DISCOVERY_URL = 'https://health.googleapis.com/$discovery/rest'; // Replace with actual discovery URL if needed
  const SCOPES = 'https://www.googleapis.com/auth/health'; // Add other scopes as needed

  let tokenClient;

  async function initClient() {
    await new Promise((resolve, reject) => {
      google.load('client', { callback: resolve, onerror: reject });
    });

    await google.client.init({
      apiKey: API_KEY,
      discoveryDocs: [DISCOVERY_URL],
    });

    tokenClient = await new Promise((resolve, reject) => {
        const client = GoogleIdentityServices.oauth2.initTokenClient({
            client_id: CLIENT_ID,
            scope: SCOPES,
            callback: (response) => {
              if (response && response.access_token) {
                resolve(response.access_token);
                } else {
                    reject(new Error('Failed to get token'));
                }
            },
            error_callback: (error) => {
                reject(error);
            },
      });
      resolve(client);
    });
   console.log("Client initialized");
   await authorize();
  }

  async function authorize() {
    if (google.client.getToken()) {
        console.log("Already authorized");
        return;
    }
    return await new Promise((resolve, reject) => {
        if(tokenClient){
           tokenClient.requestAccessToken();
           resolve();
        }
        else {
            reject(new Error('Token client not initialized'));
        }
    });
  }

  async function fetchHealthData() {
    try{
        await authorize();
        // Example: Replace with actual API method calls
        const response = await google.client.health.users.data.list();
        console.log('Health data:', response.result);
    } catch (error) {
        console.error('Error fetching data:', error);
    }
  }


  initClient().then(() => {
      fetchHealthData();
  });
  • Import Libraries:
    • https://apis.google.com/js/api.js: Loads the core Google API client.
    • https://accounts.google.com/gsi/client: Loads the Google Identity Services for authentication.
  • Configuration:
    • CLIENT_ID, API_KEY: Replace with your actual credentials.
    • DISCOVERY_URL: The URL to get the API definition. You may need to adjust this based on the final Google Health API setup.
    • SCOPES: Define the necessary permissions your app will need (e.g., to read health data).
  • initClient():
    • Loads the Google API client.
    • Initializes the client with your API key and discovery document.
    • Initializes the Google Identity Services token client.
  • authorize():
    • Checks if a token is already available.
    • If not, it calls tokenClient.requestAccessToken() to start the OAuth flow.
  • fetchHealthData():
    • Calls authorize() to ensure the user is authenticated.
    • Makes an API call to the Google Health API (replace the example with your specific calls).
    • Logs the response.
  • Error Handling: The code includes basic try...catch blocks for error handling.

Python

  1. Install the Google API Client Library:
    • Use pip to install the necessary libraries.
  2. Implement OAuth 2.0 Flow:
    • Use the google-auth-oauthlib library to handle the OAuth flow.
  3. Make API Requests:
    • Use the initialized client to make requests to the Google Health API.
import google.auth
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
import googleapiclient.discovery
import os
import json

# --- REPLACE WITH YOUR VALUES ---
CLIENT_SECRETS_FILE = 'path/to/your/client_secret.json'
API_KEY = 'YOUR_API_KEY'
SCOPES = ['https://www.googleapis.com/auth/health']  # Add other scopes as needed
DISCOVERY_URL = 'https://health.googleapis.com/$discovery/rest'  # Adjust if needed
TOKEN_FILE = 'token.json'

def get_credentials():
    """Gets or creates OAuth 2.0 credentials."""
    creds = None
    # The file token.json stores the user's access and refresh tokens, and is
    # created automatically when the authorization flow completes for the first
    # time.
    if os.path.exists(TOKEN_FILE):
        with open(TOKEN_FILE, 'r') as token:
            creds = Credentials.from_authorized_user_info(json.load(token), SCOPES)
    # If there are no (valid) credentials available, let the user log in.
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                CLIENT_SECRETS_FILE, SCOPES
            )
            creds = flow.run_local_server(port=0)
        # Save the credentials for the next run
        with open(TOKEN_FILE, 'w') as token:
            token.write(creds.to_json())
    return creds


def create_health_client(creds):
    """Creates a Google Health API client."""
    return googleapiclient.discovery.build(
        'health',
        'v1',  # Replace with the actual API version if needed
        credentials=creds,
        discoveryServiceUrl=DISCOVERY_URL,
        developerKey=API_KEY
    )

def fetch_health_data(client):
    """Fetches health data using the API client."""
    try:
        # Example: Replace with actual API method calls
        response = client.users().data().list().execute()
        print('Health data:', response)
    except Exception as e:
        print(f'Error fetching data: {e}')


if __name__ == '__main__':
    try:
        creds = get_credentials()
        health_client = create_health_client(creds)
        fetch_health_data(health_client)
    except Exception as e:
        print(f"An error occurred: {e}")
Previous
Scopes
Next
Endpoints