Cara menggunakan google-sheets-api python github

Console

1. In the Google Cloud console, go to the Credentials page:

   Go to Credentials

2. Click Create credentials, then select API key from the menu.

   The API key created dialog displays the string for your newly created key.

gcloud

You use the gcloud alpha services api-keys create command to create an API key.

Replace

from google.cloud import api_keys_v2
from google.cloud.api_keys_v2 import Key


def create_api_key(project_id: str) -> Key:
    """
    Creates and restrict an API key.

    TODO(Developer):
    1. Before running this sample,
      set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    2. Make sure you have the necessary permission to create API keys.

    Args:
        project_id: Google Cloud project id.

    Returns:
        response: Returns the created API Key.
    """

    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    key = api_keys_v2.Key()
    key.display_name = "My first API key"

    # Initialize request and set arguments.
    request = api_keys_v2.CreateKeyRequest()
    request.parent = f"projects/{project_id}/locations/global"
    request.key = key

    # Make the request and wait for the operation to complete.
    response = client.create_key(request=request).result()

    print(f"Successfully created an API key: {response.name}")
    # For authenticating with the API key, use the value in "response.key_string".
    # To restrict the usage of this API key, use the value in "response.name".
    return response

gcloud alpha services api-keys create --display-name=DISPLAY_NAME

REST

You use the keys.create method to create an API key. This request returns a ; you must poll the operation to get the information for the new key.

Replace the following values:

• 
  from google.cloud import api_keys_v2
  from google.cloud.api_keys_v2 import Key
  
  
  def create_api_key(project_id: str) -> Key:
      """
      Creates and restrict an API key.
  
      TODO(Developer):
      1. Before running this sample,
        set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
      2. Make sure you have the necessary permission to create API keys.
  
      Args:
          project_id: Google Cloud project id.
  
      Returns:
          response: Returns the created API Key.
      """
  
      # Create the API Keys client.
      client = api_keys_v2.ApiKeysClient()
  
      key = api_keys_v2.Key()
      key.display_name = "My first API key"
  
      # Initialize request and set arguments.
      request = api_keys_v2.CreateKeyRequest()
      request.parent = f"projects/{project_id}/locations/global"
      request.key = key
  
      # Make the request and wait for the operation to complete.
      response = client.create_key(request=request).result()
  
      print(f"Successfully created an API key: {response.name}")
      # For authenticating with the API key, use the value in "response.key_string".
      # To restrict the usage of this API key, use the value in "response.name".
      return response
  

  9: Optional. A descriptive name for your key.

• POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

  1: Your Google Cloud project ID or name.

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d {'"displayName" : "DISPLAY_NAME"'} \
"https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"

For more information about creating API keys using the REST API, see in the API Key API documentation.

Java

To run this sample, you must install the

POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

auth/src/main/java/CreateApiKey.java

View on GitHub

import com.google.api.apikeys.v2.ApiKeysClient;
import com.google.api.apikeys.v2.ApiTarget;
import com.google.api.apikeys.v2.CreateKeyRequest;
import com.google.api.apikeys.v2.Key;
import com.google.api.apikeys.v2.LocationName;
import com.google.api.apikeys.v2.Restrictions;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateApiKey {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(Developer): Before running this sample,
    //  1. Replace the variable(s) below.
    //  2. Set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    //  3. Make sure you have the necessary permission to create API keys.
    String projectId = "GOOGLE_CLOUD_PROJECT_ID";

    createApiKey(projectId);
  }

  // Creates an API key.
  public static void createApiKey(String projectId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `apiKeysClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {

      Key key = Key.newBuilder()
          .setDisplayName("My first API key")
          // Set the API key restriction.
          // You can also set browser/ server/ android/ ios based restrictions.
          // For more information on API key restriction, see:
          // https://cloud.google.com/docs/authentication/api-keys#api_key_restrictions
          .setRestrictions(Restrictions.newBuilder()
              // Restrict the API key usage by specifying the target service and methods.
              // The API key can only be used to authenticate the specified methods in the service.
              .addApiTargets(ApiTarget.newBuilder()
                  .setService("translate.googleapis.com")
                  .addMethods("translate.googleapis.com.TranslateText")
                  .build())
              .build())
          .build();

      // Initialize request and set arguments.
      CreateKeyRequest createKeyRequest = CreateKeyRequest.newBuilder()
          // API keys can only be global.
          .setParent(LocationName.of(projectId, "global").toString())
          .setKey(key)
          .build();

      // Make the request and wait for the operation to complete.
      Key result = apiKeysClient.createKeyAsync(createKeyRequest).get(3, TimeUnit.MINUTES);

      // For authenticating with the API key, use the value in "result.getKeyString()".
      // To restrict the usage of this API key, use the value in "result.getName()".
      System.out.printf("Successfully created an API key: %s", result.getName());
    }
  }
}

Python

To run this sample, you must install the Python Client for API Keys API.

auth/api-client/create_api_key.py

View on GitHub

from google.cloud import api_keys_v2
from google.cloud.api_keys_v2 import Key


def create_api_key(project_id: str) -> Key:
    """
    Creates and restrict an API key.

    TODO(Developer):
    1. Before running this sample,
      set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    2. Make sure you have the necessary permission to create API keys.

    Args:
        project_id: Google Cloud project id.

    Returns:
        response: Returns the created API Key.
    """

    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    key = api_keys_v2.Key()
    key.display_name = "My first API key"

    # Initialize request and set arguments.
    request = api_keys_v2.CreateKeyRequest()
    request.parent = f"projects/{project_id}/locations/global"
    request.key = key

    # Make the request and wait for the operation to complete.
    response = client.create_key(request=request).result()

    print(f"Successfully created an API key: {response.name}")
    # For authenticating with the API key, use the value in "response.key_string".
    # To restrict the usage of this API key, use the value in "response.name".
    return response

Python

This example uses the Cloud Natural Language API, which supports API keys for authentication, to demonstrate how you would provide an API key to the library.

To run this sample, you must install the Python Client for Natural Language API and the Python Client for API Keys API.

auth/api-client/authenticate_with_api_key.py

View on GitHub

from google.cloud import language_v1


def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
    """
    Authenticates with an API key for Google Language service.

    TODO(Developer): Replace these variables before running the sample.

    Args:
        quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
        api_key_string: The API key to authenticate to the service.
    """

    # Initialize the Language Service client and set the API key and the quota project id.
    client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                               "quota_project_id": quota_project_id})

    text = "Hello, world!"
    document = language_v1.Document(
        content=text, type_=language_v1.Document.Type.PLAIN_TEXT
    )

    # Make a request to analyze the sentiment of the text.
    sentiment = client.analyze_sentiment(
        request={"document": document}
    ).document_sentiment

    print(f"Text: {text}")
    print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
    print("Successfully authenticated using the API key")

Console

1. In the Google Cloud console, go to the Credentials page:

   Go to Credentials

2. Click the name of the API key that you want to restrict.

3. In the Application restrictions section, select HTTP referrers.

4. For each restriction that you want to add, click Add an item, enter the restriction, and click Done.

5. Click Save to save your changes and return to the API key list.

gcloud

1. Get the ID of the key that you want to restrict.

   The ID is not the same as the display name or the key string. You can get the ID by using the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   2 command to list the keys in your project.

2. Use the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   3 command to add HTTP referrer restrictions to an API key.

   Replace the following values:

   • 
     from google.cloud import language_v1
     
     
     def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
         """
         Authenticates with an API key for Google Language service.
     
         TODO(Developer): Replace these variables before running the sample.
     
         Args:
             quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
             api_key_string: The API key to authenticate to the service.
         """
     
         # Initialize the Language Service client and set the API key and the quota project id.
         client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                    "quota_project_id": quota_project_id})
     
         text = "Hello, world!"
         document = language_v1.Document(
             content=text, type_=language_v1.Document.Type.PLAIN_TEXT
         )
     
         # Make a request to analyze the sentiment of the text.
         sentiment = client.analyze_sentiment(
             request={"document": document}
         ).document_sentiment
     
         print(f"Text: {text}")
         print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
         print("Successfully authenticated using the API key")
     

     4: The ID of the key that you want to restrict.

   • 
     from google.cloud import language_v1
     
     
     def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
         """
         Authenticates with an API key for Google Language service.
     
         TODO(Developer): Replace these variables before running the sample.
     
         Args:
             quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
             api_key_string: The API key to authenticate to the service.
         """
     
         # Initialize the Language Service client and set the API key and the quota project id.
         client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                    "quota_project_id": quota_project_id})
     
         text = "Hello, world!"
         document = language_v1.Document(
             content=text, type_=language_v1.Document.Type.PLAIN_TEXT
         )
     
         # Make a request to analyze the sentiment of the text.
         sentiment = client.analyze_sentiment(
             request={"document": document}
         ).document_sentiment
     
         print(f"Text: {text}")
         print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
         print("Successfully authenticated using the API key")
     

     5: Your HTTP referrer restriction.

     You can add as many restrictions as needed; use commas to separate the restrictions. You must provide all referrer restrictions with the update command; the referrer restrictions provided replace any existing referrer restrictions on the key.

   gcloud alpha services api-keys update KEY_ID \
    --allowed-referrers="ALLOWED_REFERRER_1"
   

REST

1. Get the ID of the key that you want to restrict.

   The ID is not the same as the display name or the key string. You can get the ID by using the keys.list method. The ID is listed in the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   6 field of the response.

   Replace

   POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

   1 with your Google Cloud project ID or name.

   curl -X GET \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   "https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
   

2. Use the keys.patch method to add HTTP referrer restrictions to the API key.

   This request returns a ; you must poll the operation to know when the operation completes and get the operation status.

   Replace the following values:

   • 
     from google.cloud import language_v1
     
     
     def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
         """
         Authenticates with an API key for Google Language service.
     
         TODO(Developer): Replace these variables before running the sample.
     
         Args:
             quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
             api_key_string: The API key to authenticate to the service.
         """
     
         # Initialize the Language Service client and set the API key and the quota project id.
         client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                    "quota_project_id": quota_project_id})
     
         text = "Hello, world!"
         document = language_v1.Document(
             content=text, type_=language_v1.Document.Type.PLAIN_TEXT
         )
     
         # Make a request to analyze the sentiment of the text.
         sentiment = client.analyze_sentiment(
             request={"document": document}
         ).document_sentiment
     
         print(f"Text: {text}")
         print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
         print("Successfully authenticated using the API key")
     

     5: Your HTTP referrer restriction.

     You can add as many restrictions as needed; use commas to separate the restrictions. You must provide all referrer restrictions with the request; the referrer restrictions provided replace any existing referrer restrictions on the key.

   • POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

     1: Your Google Cloud project ID or name.

   • 
     from google.cloud import language_v1
     
     
     def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
         """
         Authenticates with an API key for Google Language service.
     
         TODO(Developer): Replace these variables before running the sample.
     
         Args:
             quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
             api_key_string: The API key to authenticate to the service.
         """
     
         # Initialize the Language Service client and set the API key and the quota project id.
         client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                    "quota_project_id": quota_project_id})
     
         text = "Hello, world!"
         document = language_v1.Document(
             content=text, type_=language_v1.Document.Type.PLAIN_TEXT
         )
     
         # Make a request to analyze the sentiment of the text.
         sentiment = client.analyze_sentiment(
             request={"document": document}
         ).document_sentiment
     
         print(f"Text: {text}")
         print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
         print("Successfully authenticated using the API key")
     

     4: The ID of the key that you want to restrict.

   curl -X PATCH \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json; charset=utf-8" \
   --data '{
   "restrictions" : {
   "browserKeyRestrictions": {
     "allowedReferrers": ["ALLOWED_REFERRER_1"]
   }
   }
   }' \
   "https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/KEY_ID?updateMask=restrictions"
   

For more information about adding HTTP referrer restrictions to a key using the REST API, see in the API Key API documentation.

Java

To run this sample, you must install the

POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

auth/src/main/java/RestrictApiKeyHttp.java

View on GitHub

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d {'"displayName" : "DISPLAY_NAME"'} \
"https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"

Python

To run this sample, you must install the Python Client for API Keys API.

auth/api-client/restrict_api_key_http.py

View on GitHub

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d {'"displayName" : "DISPLAY_NAME"'} \
"https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"

Console

1. In the Google Cloud console, go to the Credentials page:

   Go to Credentials

2. Click the name of the API key that you want to restrict.

3. In the Application restrictions section, select IP addresses.

4. For each IP address that you want to add, click Add an item, enter the address, and click Done.

5. Click Save to save your changes and return to the API key list.

gcloud

1. Get the ID of the key that you want to restrict.

   The ID is not the same as the display name or the key string. You can get the ID by using the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   2 command to list the keys in your project.

2. Use the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   3 command to add server (IP address) restrictions to an API key.

   Replace the following values:

   • 
     from google.cloud import language_v1
     
     
     def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
         """
         Authenticates with an API key for Google Language service.
     
         TODO(Developer): Replace these variables before running the sample.
     
         Args:
             quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
             api_key_string: The API key to authenticate to the service.
         """
     
         # Initialize the Language Service client and set the API key and the quota project id.
         client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                    "quota_project_id": quota_project_id})
     
         text = "Hello, world!"
         document = language_v1.Document(
             content=text, type_=language_v1.Document.Type.PLAIN_TEXT
         )
     
         # Make a request to analyze the sentiment of the text.
         sentiment = client.analyze_sentiment(
             request={"document": document}
         ).document_sentiment
     
         print(f"Text: {text}")
         print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
         print("Successfully authenticated using the API key")
     

     4: The ID of the key that you want to restrict.

   • curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
     

     0: Your allowed IP address.

     You can add as many IP addresses as needed; use commas to separate the addresses.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json; charset=utf-8" \
   -d {'"displayName" : "DISPLAY_NAME"'} \
   "https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"
   

   2

REST

1. Get the ID of the key that you want to restrict.

   The ID is not the same as the display name or the key string. You can get the ID by using the keys.list method. The ID is listed in the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   6 field of the response.

   Replace

   POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

   1 with your Google Cloud project ID or name.

   curl -X GET \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   "https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
   

2. Use the keys.patch method to add server (IP address) restrictions to an API key.

   This request returns a ; you must poll the operation to know when the operation completes and get the operation status.

   Replace the following values:

   • curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
     

     0: Your allowed IP address.

     You can add as many IP addresses as needed; use commas to separate the restrictions. You must provide all IP addresses with the request; the referrer restrictions provided replace any existing IP address restrictions on the key.

   • POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

     1: Your Google Cloud project ID or name.

   • 
     from google.cloud import language_v1
     
     
     def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
         """
         Authenticates with an API key for Google Language service.
     
         TODO(Developer): Replace these variables before running the sample.
     
         Args:
             quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
             api_key_string: The API key to authenticate to the service.
         """
     
         # Initialize the Language Service client and set the API key and the quota project id.
         client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                    "quota_project_id": quota_project_id})
     
         text = "Hello, world!"
         document = language_v1.Document(
             content=text, type_=language_v1.Document.Type.PLAIN_TEXT
         )
     
         # Make a request to analyze the sentiment of the text.
         sentiment = client.analyze_sentiment(
             request={"document": document}
         ).document_sentiment
     
         print(f"Text: {text}")
         print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
         print("Successfully authenticated using the API key")
     

     4: The ID of the key that you want to restrict.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json; charset=utf-8" \
   -d {'"displayName" : "DISPLAY_NAME"'} \
   "https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"
   

   4

For more information about adding IP address restrictions to a key using the REST API, see in the API Key API documentation.

Java

To run this sample, you must install the

POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

auth/src/main/java/RestrictApiKeyServer.java

View on GitHub

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d {'"displayName" : "DISPLAY_NAME"'} \
"https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"

Python

To run this sample, you must install the Python Client for API Keys API.

auth/api-client/restrict_api_key_server.py

View on GitHub

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d {'"displayName" : "DISPLAY_NAME"'} \
"https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"

Console

1. In the Google Cloud console, go to the Credentials page:

   Go to Credentials

2. Click the name of the API key that you want to restrict.

3. In the Application restrictions section, select Android apps.

4. For each Android app that you want to add, click Add an item and enter the package name and SHA-1 certificate fingerprint, then click Done.

5. Click Save to save your changes and return to the API key list.

gcloud

1. Get the ID of the key that you want to restrict.

   The ID is not the same as the display name or the key string. You can get the ID by using the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   2 command to list the keys in your project.

2. Use the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   3 command to specify the Android apps that can use an API key.

   Replace the following values:

   • 
     from google.cloud import language_v1
     
     
     def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
         """
         Authenticates with an API key for Google Language service.
     
         TODO(Developer): Replace these variables before running the sample.
     
         Args:
             quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
             api_key_string: The API key to authenticate to the service.
         """
     
         # Initialize the Language Service client and set the API key and the quota project id.
         client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                    "quota_project_id": quota_project_id})
     
         text = "Hello, world!"
         document = language_v1.Document(
             content=text, type_=language_v1.Document.Type.PLAIN_TEXT
         )
     
         # Make a request to analyze the sentiment of the text.
         sentiment = client.analyze_sentiment(
             request={"document": document}
         ).document_sentiment
     
         print(f"Text: {text}")
         print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
         print("Successfully authenticated using the API key")
     

     4: The ID of the key that you want to restrict.

   • curl -X PATCH \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     --data '{
     "restrictions" : {
     "browserKeyRestrictions": {
       "allowedReferrers": ["ALLOWED_REFERRER_1"]
     }
     }
     }' \
     "https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/KEY_ID?updateMask=restrictions"
     

     0 and

     curl -X PATCH \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     --data '{
     "restrictions" : {
     "browserKeyRestrictions": {
       "allowedReferrers": ["ALLOWED_REFERRER_1"]
     }
     }
     }' \
     "https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/KEY_ID?updateMask=restrictions"
     

     1: The app information for an Android app that can use the key.

     You can add as many apps as needed; use additional

     curl -X PATCH \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     --data '{
     "restrictions" : {
     "browserKeyRestrictions": {
       "allowedReferrers": ["ALLOWED_REFERRER_1"]
     }
     }
     }' \
     "https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/KEY_ID?updateMask=restrictions"
     

     2 flags.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json; charset=utf-8" \
   -d {'"displayName" : "DISPLAY_NAME"'} \
   "https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"
   

   7

REST

1. Get the ID of the key that you want to restrict.

   The ID is not the same as the display name or the key string. You can get the ID by using the keys.list method. The ID is listed in the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   6 field of the response.

   Replace

   POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

   1 with your Google Cloud project ID or name.

   curl -X GET \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   "https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
   

2. Use the keys.patch method to specify the Android apps that can use an API key.

   This request returns a ; you must poll the operation to know when the operation completes and get the operation status.

   Replace the following values:

   • curl -X PATCH \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     --data '{
     "restrictions" : {
     "browserKeyRestrictions": {
       "allowedReferrers": ["ALLOWED_REFERRER_1"]
     }
     }
     }' \
     "https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/KEY_ID?updateMask=restrictions"
     

     5 and PACKAGE_NAME_1: The app information for an Android app that can use the key.

     You can add the information for as many apps as needed; use commas to separate the objects. You must provide all applications with the request; the applications provided replace any existing allowed applications on the key.

   • POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

     1: Your Google Cloud project ID or name.

   • 
     from google.cloud import language_v1
     
     
     def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
         """
         Authenticates with an API key for Google Language service.
     
         TODO(Developer): Replace these variables before running the sample.
     
         Args:
             quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
             api_key_string: The API key to authenticate to the service.
         """
     
         # Initialize the Language Service client and set the API key and the quota project id.
         client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                    "quota_project_id": quota_project_id})
     
         text = "Hello, world!"
         document = language_v1.Document(
             content=text, type_=language_v1.Document.Type.PLAIN_TEXT
         )
     
         # Make a request to analyze the sentiment of the text.
         sentiment = client.analyze_sentiment(
             request={"document": document}
         ).document_sentiment
     
         print(f"Text: {text}")
         print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
         print("Successfully authenticated using the API key")
     

     4: The ID of the key that you want to restrict.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json; charset=utf-8" \
   -d {'"displayName" : "DISPLAY_NAME"'} \
   "https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"
   

   9

For more information about adding Android app restrictions to a key using the REST API, see in the API Key API documentation.

Java

To run this sample, you must install the

POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

auth/src/main/java/RestrictApiKeyAndroid.java

View on GitHub

import com.google.api.apikeys.v2.ApiKeysClient;
import com.google.api.apikeys.v2.ApiTarget;
import com.google.api.apikeys.v2.CreateKeyRequest;
import com.google.api.apikeys.v2.Key;
import com.google.api.apikeys.v2.LocationName;
import com.google.api.apikeys.v2.Restrictions;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateApiKey {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(Developer): Before running this sample,
    //  1. Replace the variable(s) below.
    //  2. Set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    //  3. Make sure you have the necessary permission to create API keys.
    String projectId = "GOOGLE_CLOUD_PROJECT_ID";

    createApiKey(projectId);
  }

  // Creates an API key.
  public static void createApiKey(String projectId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `apiKeysClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {

      Key key = Key.newBuilder()
          .setDisplayName("My first API key")
          // Set the API key restriction.
          // You can also set browser/ server/ android/ ios based restrictions.
          // For more information on API key restriction, see:
          // https://cloud.google.com/docs/authentication/api-keys#api_key_restrictions
          .setRestrictions(Restrictions.newBuilder()
              // Restrict the API key usage by specifying the target service and methods.
              // The API key can only be used to authenticate the specified methods in the service.
              .addApiTargets(ApiTarget.newBuilder()
                  .setService("translate.googleapis.com")
                  .addMethods("translate.googleapis.com.TranslateText")
                  .build())
              .build())
          .build();

      // Initialize request and set arguments.
      CreateKeyRequest createKeyRequest = CreateKeyRequest.newBuilder()
          // API keys can only be global.
          .setParent(LocationName.of(projectId, "global").toString())
          .setKey(key)
          .build();

      // Make the request and wait for the operation to complete.
      Key result = apiKeysClient.createKeyAsync(createKeyRequest).get(3, TimeUnit.MINUTES);

      // For authenticating with the API key, use the value in "result.getKeyString()".
      // To restrict the usage of this API key, use the value in "result.getName()".
      System.out.printf("Successfully created an API key: %s", result.getName());
    }
  }
}

Python

To run this sample, you must install the Python Client for API Keys API.

auth/api-client/restrict_api_key_android.py

View on GitHub

import com.google.api.apikeys.v2.ApiKeysClient;
import com.google.api.apikeys.v2.ApiTarget;
import com.google.api.apikeys.v2.CreateKeyRequest;
import com.google.api.apikeys.v2.Key;
import com.google.api.apikeys.v2.LocationName;
import com.google.api.apikeys.v2.Restrictions;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateApiKey {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(Developer): Before running this sample,
    //  1. Replace the variable(s) below.
    //  2. Set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    //  3. Make sure you have the necessary permission to create API keys.
    String projectId = "GOOGLE_CLOUD_PROJECT_ID";

    createApiKey(projectId);
  }

  // Creates an API key.
  public static void createApiKey(String projectId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `apiKeysClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {

      Key key = Key.newBuilder()
          .setDisplayName("My first API key")
          // Set the API key restriction.
          // You can also set browser/ server/ android/ ios based restrictions.
          // For more information on API key restriction, see:
          // https://cloud.google.com/docs/authentication/api-keys#api_key_restrictions
          .setRestrictions(Restrictions.newBuilder()
              // Restrict the API key usage by specifying the target service and methods.
              // The API key can only be used to authenticate the specified methods in the service.
              .addApiTargets(ApiTarget.newBuilder()
                  .setService("translate.googleapis.com")
                  .addMethods("translate.googleapis.com.TranslateText")
                  .build())
              .build())
          .build();

      // Initialize request and set arguments.
      CreateKeyRequest createKeyRequest = CreateKeyRequest.newBuilder()
          // API keys can only be global.
          .setParent(LocationName.of(projectId, "global").toString())
          .setKey(key)
          .build();

      // Make the request and wait for the operation to complete.
      Key result = apiKeysClient.createKeyAsync(createKeyRequest).get(3, TimeUnit.MINUTES);

      // For authenticating with the API key, use the value in "result.getKeyString()".
      // To restrict the usage of this API key, use the value in "result.getName()".
      System.out.printf("Successfully created an API key: %s", result.getName());
    }
  }
}

Console

1. In the Google Cloud console, go to the Credentials page:

   Go to Credentials

2. Click the name of the API key that you want to restrict.

3. In the Application restrictions section, select iOS apps.

4. For each iOS app that you want to add, click Add an item and enter the bundle ID, then click Done.

5. Click Save to save your changes and return to the API key list.

gcloud

1. Get the ID of the key that you want to restrict.

   The ID is not the same as the display name or the key string. You can get the ID by using the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   2 command to list the keys in your project.

2. Use the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   3 method to specify the iOS apps that can use the key.

   Replace the following values:

   • 
     from google.cloud import language_v1
     
     
     def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
         """
         Authenticates with an API key for Google Language service.
     
         TODO(Developer): Replace these variables before running the sample.
     
         Args:
             quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
             api_key_string: The API key to authenticate to the service.
         """
     
         # Initialize the Language Service client and set the API key and the quota project id.
         client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                    "quota_project_id": quota_project_id})
     
         text = "Hello, world!"
         document = language_v1.Document(
             content=text, type_=language_v1.Document.Type.PLAIN_TEXT
         )
     
         # Make a request to analyze the sentiment of the text.
         sentiment = client.analyze_sentiment(
             request={"document": document}
         ).document_sentiment
     
         print(f"Text: {text}")
         print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
         print("Successfully authenticated using the API key")
     

     4: The ID of the key that you want to restrict.

   • curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d {'"displayName" : "DISPLAY_NAME"'} \
     "https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"
     

     02: The bundle ID of an iOS app that you want to be able to use this API key.

     You can add as many bundle IDs as needed; use commas to separate the IDs.

   
   import com.google.api.apikeys.v2.ApiKeysClient;
   import com.google.api.apikeys.v2.ApiTarget;
   import com.google.api.apikeys.v2.CreateKeyRequest;
   import com.google.api.apikeys.v2.Key;
   import com.google.api.apikeys.v2.LocationName;
   import com.google.api.apikeys.v2.Restrictions;
   import java.io.IOException;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.TimeoutException;
   
   public class CreateApiKey {
   
     public static void main(String[] args)
         throws IOException, ExecutionException, InterruptedException, TimeoutException {
       // TODO(Developer): Before running this sample,
       //  1. Replace the variable(s) below.
       //  2. Set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
       //  3. Make sure you have the necessary permission to create API keys.
       String projectId = "GOOGLE_CLOUD_PROJECT_ID";
   
       createApiKey(projectId);
     }
   
     // Creates an API key.
     public static void createApiKey(String projectId)
         throws IOException, ExecutionException, InterruptedException, TimeoutException {
       // Initialize client that will be used to send requests. This client only needs to be created
       // once, and can be reused for multiple requests. After completing all of your requests, call
       // the `apiKeysClient.close()` method on the client to safely
       // clean up any remaining background resources.
       try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {
   
         Key key = Key.newBuilder()
             .setDisplayName("My first API key")
             // Set the API key restriction.
             // You can also set browser/ server/ android/ ios based restrictions.
             // For more information on API key restriction, see:
             // https://cloud.google.com/docs/authentication/api-keys#api_key_restrictions
             .setRestrictions(Restrictions.newBuilder()
                 // Restrict the API key usage by specifying the target service and methods.
                 // The API key can only be used to authenticate the specified methods in the service.
                 .addApiTargets(ApiTarget.newBuilder()
                     .setService("translate.googleapis.com")
                     .addMethods("translate.googleapis.com.TranslateText")
                     .build())
                 .build())
             .build();
   
         // Initialize request and set arguments.
         CreateKeyRequest createKeyRequest = CreateKeyRequest.newBuilder()
             // API keys can only be global.
             .setParent(LocationName.of(projectId, "global").toString())
             .setKey(key)
             .build();
   
         // Make the request and wait for the operation to complete.
         Key result = apiKeysClient.createKeyAsync(createKeyRequest).get(3, TimeUnit.MINUTES);
   
         // For authenticating with the API key, use the value in "result.getKeyString()".
         // To restrict the usage of this API key, use the value in "result.getName()".
         System.out.printf("Successfully created an API key: %s", result.getName());
       }
     }
   }

   2

REST

1. Get the ID of the key that you want to restrict.

   The ID is not the same as the display name or the key string. You can get the ID by using the keys.list method. The ID is listed in the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   6 field of the response.

   Replace

   POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

   1 with your Google Cloud project ID or name.

   curl -X GET \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   "https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
   

2. Use the keys.patch method to specify the iOS apps that can use an API key.

   This request returns a ; you must poll the operation to know when the operation completes and get the operation status.

   Replace the following values:

   • curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d {'"displayName" : "DISPLAY_NAME"'} \
     "https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"
     

     02: The bundle ID of an iOS app that can use the key.

     You can add the information for as many apps as needed; use commas to separate the bundle IDs. You must provide all bundle IDs with the request; the bundle IDs provided replace any existing allowed applications on the key.

   • POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

     1: Your Google Cloud project ID or name.

   • 
     from google.cloud import language_v1
     
     
     def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
         """
         Authenticates with an API key for Google Language service.
     
         TODO(Developer): Replace these variables before running the sample.
     
         Args:
             quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
             api_key_string: The API key to authenticate to the service.
         """
     
         # Initialize the Language Service client and set the API key and the quota project id.
         client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                    "quota_project_id": quota_project_id})
     
         text = "Hello, world!"
         document = language_v1.Document(
             content=text, type_=language_v1.Document.Type.PLAIN_TEXT
         )
     
         # Make a request to analyze the sentiment of the text.
         sentiment = client.analyze_sentiment(
             request={"document": document}
         ).document_sentiment
     
         print(f"Text: {text}")
         print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
         print("Successfully authenticated using the API key")
     

     4: The ID of the key that you want to restrict.

   
   import com.google.api.apikeys.v2.ApiKeysClient;
   import com.google.api.apikeys.v2.ApiTarget;
   import com.google.api.apikeys.v2.CreateKeyRequest;
   import com.google.api.apikeys.v2.Key;
   import com.google.api.apikeys.v2.LocationName;
   import com.google.api.apikeys.v2.Restrictions;
   import java.io.IOException;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.TimeoutException;
   
   public class CreateApiKey {
   
     public static void main(String[] args)
         throws IOException, ExecutionException, InterruptedException, TimeoutException {
       // TODO(Developer): Before running this sample,
       //  1. Replace the variable(s) below.
       //  2. Set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
       //  3. Make sure you have the necessary permission to create API keys.
       String projectId = "GOOGLE_CLOUD_PROJECT_ID";
   
       createApiKey(projectId);
     }
   
     // Creates an API key.
     public static void createApiKey(String projectId)
         throws IOException, ExecutionException, InterruptedException, TimeoutException {
       // Initialize client that will be used to send requests. This client only needs to be created
       // once, and can be reused for multiple requests. After completing all of your requests, call
       // the `apiKeysClient.close()` method on the client to safely
       // clean up any remaining background resources.
       try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {
   
         Key key = Key.newBuilder()
             .setDisplayName("My first API key")
             // Set the API key restriction.
             // You can also set browser/ server/ android/ ios based restrictions.
             // For more information on API key restriction, see:
             // https://cloud.google.com/docs/authentication/api-keys#api_key_restrictions
             .setRestrictions(Restrictions.newBuilder()
                 // Restrict the API key usage by specifying the target service and methods.
                 // The API key can only be used to authenticate the specified methods in the service.
                 .addApiTargets(ApiTarget.newBuilder()
                     .setService("translate.googleapis.com")
                     .addMethods("translate.googleapis.com.TranslateText")
                     .build())
                 .build())
             .build();
   
         // Initialize request and set arguments.
         CreateKeyRequest createKeyRequest = CreateKeyRequest.newBuilder()
             // API keys can only be global.
             .setParent(LocationName.of(projectId, "global").toString())
             .setKey(key)
             .build();
   
         // Make the request and wait for the operation to complete.
         Key result = apiKeysClient.createKeyAsync(createKeyRequest).get(3, TimeUnit.MINUTES);
   
         // For authenticating with the API key, use the value in "result.getKeyString()".
         // To restrict the usage of this API key, use the value in "result.getName()".
         System.out.printf("Successfully created an API key: %s", result.getName());
       }
     }
   }

   4

For more information about adding iOS app restrictions to a key using the REST API, see in the API Key API documentation.

Java

To run this sample, you must install the

POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

auth/src/main/java/RestrictApiKeyIos.java

View on GitHub

import com.google.api.apikeys.v2.ApiKeysClient;
import com.google.api.apikeys.v2.ApiTarget;
import com.google.api.apikeys.v2.CreateKeyRequest;
import com.google.api.apikeys.v2.Key;
import com.google.api.apikeys.v2.LocationName;
import com.google.api.apikeys.v2.Restrictions;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateApiKey {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(Developer): Before running this sample,
    //  1. Replace the variable(s) below.
    //  2. Set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    //  3. Make sure you have the necessary permission to create API keys.
    String projectId = "GOOGLE_CLOUD_PROJECT_ID";

    createApiKey(projectId);
  }

  // Creates an API key.
  public static void createApiKey(String projectId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `apiKeysClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {

      Key key = Key.newBuilder()
          .setDisplayName("My first API key")
          // Set the API key restriction.
          // You can also set browser/ server/ android/ ios based restrictions.
          // For more information on API key restriction, see:
          // https://cloud.google.com/docs/authentication/api-keys#api_key_restrictions
          .setRestrictions(Restrictions.newBuilder()
              // Restrict the API key usage by specifying the target service and methods.
              // The API key can only be used to authenticate the specified methods in the service.
              .addApiTargets(ApiTarget.newBuilder()
                  .setService("translate.googleapis.com")
                  .addMethods("translate.googleapis.com.TranslateText")
                  .build())
              .build())
          .build();

      // Initialize request and set arguments.
      CreateKeyRequest createKeyRequest = CreateKeyRequest.newBuilder()
          // API keys can only be global.
          .setParent(LocationName.of(projectId, "global").toString())
          .setKey(key)
          .build();

      // Make the request and wait for the operation to complete.
      Key result = apiKeysClient.createKeyAsync(createKeyRequest).get(3, TimeUnit.MINUTES);

      // For authenticating with the API key, use the value in "result.getKeyString()".
      // To restrict the usage of this API key, use the value in "result.getName()".
      System.out.printf("Successfully created an API key: %s", result.getName());
    }
  }
}

Python

To run this sample, you must install the Python Client for API Keys API.

auth/api-client/restrict_api_key_ios.py

View on GitHub

import com.google.api.apikeys.v2.ApiKeysClient;
import com.google.api.apikeys.v2.ApiTarget;
import com.google.api.apikeys.v2.CreateKeyRequest;
import com.google.api.apikeys.v2.Key;
import com.google.api.apikeys.v2.LocationName;
import com.google.api.apikeys.v2.Restrictions;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateApiKey {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(Developer): Before running this sample,
    //  1. Replace the variable(s) below.
    //  2. Set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    //  3. Make sure you have the necessary permission to create API keys.
    String projectId = "GOOGLE_CLOUD_PROJECT_ID";

    createApiKey(projectId);
  }

  // Creates an API key.
  public static void createApiKey(String projectId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `apiKeysClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {

      Key key = Key.newBuilder()
          .setDisplayName("My first API key")
          // Set the API key restriction.
          // You can also set browser/ server/ android/ ios based restrictions.
          // For more information on API key restriction, see:
          // https://cloud.google.com/docs/authentication/api-keys#api_key_restrictions
          .setRestrictions(Restrictions.newBuilder()
              // Restrict the API key usage by specifying the target service and methods.
              // The API key can only be used to authenticate the specified methods in the service.
              .addApiTargets(ApiTarget.newBuilder()
                  .setService("translate.googleapis.com")
                  .addMethods("translate.googleapis.com.TranslateText")
                  .build())
              .build())
          .build();

      // Initialize request and set arguments.
      CreateKeyRequest createKeyRequest = CreateKeyRequest.newBuilder()
          // API keys can only be global.
          .setParent(LocationName.of(projectId, "global").toString())
          .setKey(key)
          .build();

      // Make the request and wait for the operation to complete.
      Key result = apiKeysClient.createKeyAsync(createKeyRequest).get(3, TimeUnit.MINUTES);

      // For authenticating with the API key, use the value in "result.getKeyString()".
      // To restrict the usage of this API key, use the value in "result.getName()".
      System.out.printf("Successfully created an API key: %s", result.getName());
    }
  }
}

Console

1. In the Google Cloud console, go to the Credentials page:

   Go to Credentials

2. Click the name of the API key that you want to restrict.

3. In the API restrictions section, click Restrict key.

4. Select all APIs that your API key will be used to access.

5. Click Save to save your changes and return to the API key list.

gcloud

1. Get the ID of the key that you want to restrict.

   The ID is not the same as the display name or the key string. You can get the ID by using the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   2 command to list the keys in your project.

2. Use the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   3 command to specify which services an API key can be used to authenticate to.

   Replace the following values:

   • 
     from google.cloud import language_v1
     
     
     def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
         """
         Authenticates with an API key for Google Language service.
     
         TODO(Developer): Replace these variables before running the sample.
     
         Args:
             quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
             api_key_string: The API key to authenticate to the service.
         """
     
         # Initialize the Language Service client and set the API key and the quota project id.
         client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                    "quota_project_id": quota_project_id})
     
         text = "Hello, world!"
         document = language_v1.Document(
             content=text, type_=language_v1.Document.Type.PLAIN_TEXT
         )
     
         # Make a request to analyze the sentiment of the text.
         sentiment = client.analyze_sentiment(
             request={"document": document}
         ).document_sentiment
     
         print(f"Text: {text}")
         print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
         print("Successfully authenticated using the API key")
     

     4: The ID of the key that you want to restrict.

   • curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d {'"displayName" : "DISPLAY_NAME"'} \
     "https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"
     

     12,

     curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d {'"displayName" : "DISPLAY_NAME"'} \
     "https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"
     

     13...: The service names of the APIs that the key can be used to access.

     You must provide all service names with the update command; the service names provided replace any existing services on the key.

   You can find the service name by searching for the API on the API dashboard. Service names are strings like

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json; charset=utf-8" \
   -d {'"displayName" : "DISPLAY_NAME"'} \
   "https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"
   

   14.

   
   import com.google.api.apikeys.v2.ApiKeysClient;
   import com.google.api.apikeys.v2.ApiTarget;
   import com.google.api.apikeys.v2.CreateKeyRequest;
   import com.google.api.apikeys.v2.Key;
   import com.google.api.apikeys.v2.LocationName;
   import com.google.api.apikeys.v2.Restrictions;
   import java.io.IOException;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.TimeoutException;
   
   public class CreateApiKey {
   
     public static void main(String[] args)
         throws IOException, ExecutionException, InterruptedException, TimeoutException {
       // TODO(Developer): Before running this sample,
       //  1. Replace the variable(s) below.
       //  2. Set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
       //  3. Make sure you have the necessary permission to create API keys.
       String projectId = "GOOGLE_CLOUD_PROJECT_ID";
   
       createApiKey(projectId);
     }
   
     // Creates an API key.
     public static void createApiKey(String projectId)
         throws IOException, ExecutionException, InterruptedException, TimeoutException {
       // Initialize client that will be used to send requests. This client only needs to be created
       // once, and can be reused for multiple requests. After completing all of your requests, call
       // the `apiKeysClient.close()` method on the client to safely
       // clean up any remaining background resources.
       try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {
   
         Key key = Key.newBuilder()
             .setDisplayName("My first API key")
             // Set the API key restriction.
             // You can also set browser/ server/ android/ ios based restrictions.
             // For more information on API key restriction, see:
             // https://cloud.google.com/docs/authentication/api-keys#api_key_restrictions
             .setRestrictions(Restrictions.newBuilder()
                 // Restrict the API key usage by specifying the target service and methods.
                 // The API key can only be used to authenticate the specified methods in the service.
                 .addApiTargets(ApiTarget.newBuilder()
                     .setService("translate.googleapis.com")
                     .addMethods("translate.googleapis.com.TranslateText")
                     .build())
                 .build())
             .build();
   
         // Initialize request and set arguments.
         CreateKeyRequest createKeyRequest = CreateKeyRequest.newBuilder()
             // API keys can only be global.
             .setParent(LocationName.of(projectId, "global").toString())
             .setKey(key)
             .build();
   
         // Make the request and wait for the operation to complete.
         Key result = apiKeysClient.createKeyAsync(createKeyRequest).get(3, TimeUnit.MINUTES);
   
         // For authenticating with the API key, use the value in "result.getKeyString()".
         // To restrict the usage of this API key, use the value in "result.getName()".
         System.out.printf("Successfully created an API key: %s", result.getName());
       }
     }
   }

   7

REST

1. Get the ID of the key that you want to restrict.

   The ID is not the same as the display name or the key string. You can get the ID by using the keys.list method. The ID is listed in the

   
   from google.cloud import language_v1
   
   
   def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
       """
       Authenticates with an API key for Google Language service.
   
       TODO(Developer): Replace these variables before running the sample.
   
       Args:
           quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
           api_key_string: The API key to authenticate to the service.
       """
   
       # Initialize the Language Service client and set the API key and the quota project id.
       client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                  "quota_project_id": quota_project_id})
   
       text = "Hello, world!"
       document = language_v1.Document(
           content=text, type_=language_v1.Document.Type.PLAIN_TEXT
       )
   
       # Make a request to analyze the sentiment of the text.
       sentiment = client.analyze_sentiment(
           request={"document": document}
       ).document_sentiment
   
       print(f"Text: {text}")
       print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
       print("Successfully authenticated using the API key")
   

   6 field of the response.

   Replace

   POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

   1 with your Google Cloud project ID or name.

   curl -X GET \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   "https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
   

2. Use the keys.patch method to specify which services an API key can be used to authenticate to.

   This request returns a ; you must poll the operation to know when the operation completes and get the operation status.

   Replace the following values:

   • curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d {'"displayName" : "DISPLAY_NAME"'} \
     "https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"
     

     12,

     curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d {'"displayName" : "DISPLAY_NAME"'} \
     "https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"
     

     13...: The service names of the APIs that the key can be used to access.

     You must provide all service names with the request; the service names provided replace any existing services on the key.

     You can find the service name by searching for the API on the API dashboard. Service names are strings like

     curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d {'"displayName" : "DISPLAY_NAME"'} \
     "https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"
     

     14.

   • POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

     1: Your Google Cloud project ID or name.

   • 
     from google.cloud import language_v1
     
     
     def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
         """
         Authenticates with an API key for Google Language service.
     
         TODO(Developer): Replace these variables before running the sample.
     
         Args:
             quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
             api_key_string: The API key to authenticate to the service.
         """
     
         # Initialize the Language Service client and set the API key and the quota project id.
         client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                                    "quota_project_id": quota_project_id})
     
         text = "Hello, world!"
         document = language_v1.Document(
             content=text, type_=language_v1.Document.Type.PLAIN_TEXT
         )
     
         # Make a request to analyze the sentiment of the text.
         sentiment = client.analyze_sentiment(
             request={"document": document}
         ).document_sentiment
     
         print(f"Text: {text}")
         print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
         print("Successfully authenticated using the API key")
     

     4: The ID of the key that you want to restrict.

   
   import com.google.api.apikeys.v2.ApiKeysClient;
   import com.google.api.apikeys.v2.ApiTarget;
   import com.google.api.apikeys.v2.CreateKeyRequest;
   import com.google.api.apikeys.v2.Key;
   import com.google.api.apikeys.v2.LocationName;
   import com.google.api.apikeys.v2.Restrictions;
   import java.io.IOException;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.TimeoutException;
   
   public class CreateApiKey {
   
     public static void main(String[] args)
         throws IOException, ExecutionException, InterruptedException, TimeoutException {
       // TODO(Developer): Before running this sample,
       //  1. Replace the variable(s) below.
       //  2. Set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
       //  3. Make sure you have the necessary permission to create API keys.
       String projectId = "GOOGLE_CLOUD_PROJECT_ID";
   
       createApiKey(projectId);
     }
   
     // Creates an API key.
     public static void createApiKey(String projectId)
         throws IOException, ExecutionException, InterruptedException, TimeoutException {
       // Initialize client that will be used to send requests. This client only needs to be created
       // once, and can be reused for multiple requests. After completing all of your requests, call
       // the `apiKeysClient.close()` method on the client to safely
       // clean up any remaining background resources.
       try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {
   
         Key key = Key.newBuilder()
             .setDisplayName("My first API key")
             // Set the API key restriction.
             // You can also set browser/ server/ android/ ios based restrictions.
             // For more information on API key restriction, see:
             // https://cloud.google.com/docs/authentication/api-keys#api_key_restrictions
             .setRestrictions(Restrictions.newBuilder()
                 // Restrict the API key usage by specifying the target service and methods.
                 // The API key can only be used to authenticate the specified methods in the service.
                 .addApiTargets(ApiTarget.newBuilder()
                     .setService("translate.googleapis.com")
                     .addMethods("translate.googleapis.com.TranslateText")
                     .build())
                 .build())
             .build();
   
         // Initialize request and set arguments.
         CreateKeyRequest createKeyRequest = CreateKeyRequest.newBuilder()
             // API keys can only be global.
             .setParent(LocationName.of(projectId, "global").toString())
             .setKey(key)
             .build();
   
         // Make the request and wait for the operation to complete.
         Key result = apiKeysClient.createKeyAsync(createKeyRequest).get(3, TimeUnit.MINUTES);
   
         // For authenticating with the API key, use the value in "result.getKeyString()".
         // To restrict the usage of this API key, use the value in "result.getName()".
         System.out.printf("Successfully created an API key: %s", result.getName());
       }
     }
   }

   9

For more information about adding API restrictions to a key using the REST API, see in the API Key API documentation.

Java

To run this sample, you must install the

POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

auth/src/main/java/RestrictApiKeyApi.java

View on GitHub

from google.cloud import api_keys_v2
from google.cloud.api_keys_v2 import Key


def create_api_key(project_id: str) -> Key:
    """
    Creates and restrict an API key.

    TODO(Developer):
    1. Before running this sample,
      set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    2. Make sure you have the necessary permission to create API keys.

    Args:
        project_id: Google Cloud project id.

    Returns:
        response: Returns the created API Key.
    """

    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    key = api_keys_v2.Key()
    key.display_name = "My first API key"

    # Initialize request and set arguments.
    request = api_keys_v2.CreateKeyRequest()
    request.parent = f"projects/{project_id}/locations/global"
    request.key = key

    # Make the request and wait for the operation to complete.
    response = client.create_key(request=request).result()

    print(f"Successfully created an API key: {response.name}")
    # For authenticating with the API key, use the value in "response.key_string".
    # To restrict the usage of this API key, use the value in "response.name".
    return response

Python

To run this sample, you must install the Python Client for API Keys API.

auth/api-client/restrict_api_key_api.py

View on GitHub

from google.cloud import api_keys_v2
from google.cloud.api_keys_v2 import Key


def create_api_key(project_id: str) -> Key:
    """
    Creates and restrict an API key.

    TODO(Developer):
    1. Before running this sample,
      set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    2. Make sure you have the necessary permission to create API keys.

    Args:
        project_id: Google Cloud project id.

    Returns:
        response: Returns the created API Key.
    """

    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    key = api_keys_v2.Key()
    key.display_name = "My first API key"

    # Initialize request and set arguments.
    request = api_keys_v2.CreateKeyRequest()
    request.parent = f"projects/{project_id}/locations/global"
    request.key = key

    # Make the request and wait for the operation to complete.
    response = client.create_key(request=request).result()

    print(f"Successfully created an API key: {response.name}")
    # For authenticating with the API key, use the value in "response.key_string".
    # To restrict the usage of this API key, use the value in "response.name".
    return response

gcloud

You use the gcloud alpha services api-keys lookup command to get the project ID from a key string.

from google.cloud import api_keys_v2
from google.cloud.api_keys_v2 import Key


def create_api_key(project_id: str) -> Key:
    """
    Creates and restrict an API key.

    TODO(Developer):
    1. Before running this sample,
      set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    2. Make sure you have the necessary permission to create API keys.

    Args:
        project_id: Google Cloud project id.

    Returns:
        response: Returns the created API Key.
    """

    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    key = api_keys_v2.Key()
    key.display_name = "My first API key"

    # Initialize request and set arguments.
    request = api_keys_v2.CreateKeyRequest()
    request.parent = f"projects/{project_id}/locations/global"
    request.key = key

    # Make the request and wait for the operation to complete.
    response = client.create_key(request=request).result()

    print(f"Successfully created an API key: {response.name}")
    # For authenticating with the API key, use the value in "response.key_string".
    # To restrict the usage of this API key, use the value in "response.name".
    return response

REST

You use the lookupKey method to get the project ID from a key string.

from google.cloud import api_keys_v2
from google.cloud.api_keys_v2 import Key


def create_api_key(project_id: str) -> Key:
    """
    Creates and restrict an API key.

    TODO(Developer):
    1. Before running this sample,
      set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    2. Make sure you have the necessary permission to create API keys.

    Args:
        project_id: Google Cloud project id.

    Returns:
        response: Returns the created API Key.
    """

    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    key = api_keys_v2.Key()
    key.display_name = "My first API key"

    # Initialize request and set arguments.
    request = api_keys_v2.CreateKeyRequest()
    request.parent = f"projects/{project_id}/locations/global"
    request.key = key

    # Make the request and wait for the operation to complete.
    response = client.create_key(request=request).result()

    print(f"Successfully created an API key: {response.name}")
    # For authenticating with the API key, use the value in "response.key_string".
    # To restrict the usage of this API key, use the value in "response.name".
    return response

Java

To run this sample, you must install the

POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

auth/src/main/java/LookupApiKey.java

View on GitHub

from google.cloud import api_keys_v2
from google.cloud.api_keys_v2 import Key


def create_api_key(project_id: str) -> Key:
    """
    Creates and restrict an API key.

    TODO(Developer):
    1. Before running this sample,
      set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    2. Make sure you have the necessary permission to create API keys.

    Args:
        project_id: Google Cloud project id.

    Returns:
        response: Returns the created API Key.
    """

    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    key = api_keys_v2.Key()
    key.display_name = "My first API key"

    # Initialize request and set arguments.
    request = api_keys_v2.CreateKeyRequest()
    request.parent = f"projects/{project_id}/locations/global"
    request.key = key

    # Make the request and wait for the operation to complete.
    response = client.create_key(request=request).result()

    print(f"Successfully created an API key: {response.name}")
    # For authenticating with the API key, use the value in "response.key_string".
    # To restrict the usage of this API key, use the value in "response.name".
    return response

Python

To run this sample, you must install the Python Client for API Keys API.

auth/api-client/lookup_api_key.py

View on GitHub

from google.cloud import api_keys_v2
from google.cloud.api_keys_v2 import Key


def create_api_key(project_id: str) -> Key:
    """
    Creates and restrict an API key.

    TODO(Developer):
    1. Before running this sample,
      set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    2. Make sure you have the necessary permission to create API keys.

    Args:
        project_id: Google Cloud project id.

    Returns:
        response: Returns the created API Key.
    """

    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    key = api_keys_v2.Key()
    key.display_name = "My first API key"

    # Initialize request and set arguments.
    request = api_keys_v2.CreateKeyRequest()
    request.parent = f"projects/{project_id}/locations/global"
    request.key = key

    # Make the request and wait for the operation to complete.
    response = client.create_key(request=request).result()

    print(f"Successfully created an API key: {response.name}")
    # For authenticating with the API key, use the value in "response.key_string".
    # To restrict the usage of this API key, use the value in "response.name".
    return response