Maps Static API: API キーと署名の取得

注: 新規のお申し込み時または新規のお客様は、Google Maps Platform プレミアムプランをご利用いただけません。

認証方式を選択する

Google Maps Platform を使用するには、API キーとデジタル署名またはクライアント ID とデジタル署名を使用してリクエストを認証する必要があります。コードでのクライアント ID の使用を最小限にするため、可能であれば API キーとデジタル署名を使用してください。

どちらの方式で認証するかは、お客様がご利用のラインセスによって決まります。

プレミアムプランをご利用の場合は、API キーとデジタル署名、またはクライアント ID とデジタル署名を使用できます。
以前のライセンスをご利用の場合は、クライアント ID とデジタル署名を使用する必要があります。

使用する認証方式を決定する際は、以下の点を考慮してください。

API キー（プレミアムプラン）（推奨） - API キーを使用してリクエストを認証する場合:
- Google Cloud Console の API ページですべての API を管理できます。
- Cloud Console で、リアルタイムの使用状況データと過去 30 日間の使用状況データを確認できます。
- リクエストに channel パラメータを追加すると、より詳細な使用状況レポートを表示できます。
- Google Cloud Console で、30 日以上のデータが反映された使用状況レポートを表示できます。
- 不正使用を防ぐため、API キーを制限できます。
クライアント ID（プレミアムプランまたは以前のライセンス）- クライアント ID を使用してリクエストを認証する場合:
- リクエストに channel パラメータを追加すると、より詳細な使用状況レポートを表示できます。
- Google Cloud Console で、30 日以上のデータが反映された使用状況レポートを表示できます。
- Maps JavaScript API で Maps Analytics ツールを使用できます。

API キーとデジタル署名を使用した認証

API キーを作成する

少なくとも 1 つの API キーをプロジェクトに関連付ける必要があります。

API キーを取得するには:

Cloud Console に移動します。
プロジェクトのプルダウンを開き、プレミアムプランの購入時に作成されたプロジェクトを選択します。プロジェクト名は、Google Maps API for Business、Google Maps for Work、または Google Maps で始まります。

注: プレミアムプランのすべての機能をご利用になるには、お客様のプレミアムアカウントに関連付けられたプロジェクトを使用する必要があります。ライセンスの購入時に、gme-[company] > proj-[number] ([type]) の形式のプレミアムアセット名がお客様に通知されています。適切なプロジェクトにアクセスするため、console.cloud.google.com/project/number（number はお客様のプロジェクト番号）を使用し、プロジェクトオーナーとして Cloud Console にログインしてください。プロジェクトオーナーはウェルカムレターに記載されています。

メニューボタンをクリックし、[Google Maps Platform] > [認証情報] を選択します。
[認証情報] ページで、[認証情報を作成] > [API キー] をクリックします。
[API キーを作成しました] ダイアログに新しい API キー（暗号化された文字列）が表示されます。
[閉じる] をクリックします。
新しく作成した API キーが [認証情報] ページの [API キー] に表示されます。

リクエストに API キーを追加する

すべての Google Maps Platform リクエストに API キーを追加する必要があります。次の例では、YOUR_API_KEY を API キーに置き換えます。

https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&key=YOUR_API_KEY

API キーを使用するリクエストには HTTPS が必要です。クライアント ID を使用するリクエストの場合、HTTPS は必須ではありませんが、推奨されています。ユーザーの位置情報などの機密性の高いユーザーデータをリクエストに含めるアプリケーションにも、HTTPS が必要です。

API キーの制限

許可したリクエストにのみ API キーを使用するよう制限することで、アプリケーションのセキュリティが向上します。以下の手順に沿って API キーの制限を設定することを強くおすすめします。詳しくは、API セキュリティに関するベストプラクティスをご覧ください。

API キーを制限するには:

[Google Maps Platform] > [認証情報] ページに移動します。

[認証情報] ページに移動
制限を設定する API キーを選択します。選択した API キーのプロパティページが表示されます。
[キーの制限] で、次の制限を設定します。

アプリケーションの制限:

指定したウェブサイトからのリクエストを受け入れるには、[アプリケーションの制限] のリストで [HTTP リファラー（ウェブサイト）] を選択します。
参照元のウェブサイトを 1 つ以上指定します。たとえば、*.google.com を指定すると、google.com で終わるすべてのサイト（https://developers.google.com など）からのリクエストを受け入れます。

注: 参照元が file:// の場合、キーの制限へ追加するには特殊な表現が必要です。「file://」の部分を「__file_url__」に置き換えてから、キーの制限に追加してください。たとえば、「file:///path/to/」は「__file_url__//path/to/*」になります。file:// 参照元を有効にしたら、使用量を定期的にチェックして、適切に運用されているか確認することをおすすめします。

API の制限:

[キーを制限] をクリックします。
[API を選択] プルダウンから [Google Maps Platform] を選択します。（Google Maps Platform がリストに表示されない場合は、この API を有効にする必要があります。）

変更が完了したら、[保存] をクリックします。

デジタル署名を生成する

API キーを指定した key パラメータを使用して Google Maps Platform API をリクエストする場合は、デジタル署名を指定した signature パラメータも追加する必要があります。このデジタル署名は、共有 URL 署名シークレットを使用して生成します。共有シークレットは Google Cloud Console で確認できます。

署名プロセスでは、暗号化アルゴリズムを使用して URL と共有シークレットを結合し、一意の署名が生成されます。この一意の署名により、お客様の API キーを使用してリクエストを生成するサイトは、いずれも許可されたサイトであることがわかります。

デジタル署名は、次の 2 ステップのプロセスで作成します。

ステップ 1: URL 署名シークレットを取得する - Cloud Console で取得できます。
ステップ 2: デジタル署名を生成する - URL 署名シークレットを使用します。

ステップ 1: URL 署名シークレットを取得する

暗号 URL 署名シークレットは Cloud Console で取得できます。シークレット（秘密鍵）は URL 用修正 Base64 でエンコードされます。このシークレットはお客様と Google の間で共有され、お客様の API キーに固有の情報です。URL 署名シークレットが第三者に知られないように注意する必要があります。署名シークレットをリクエストに渡したり、ウェブサイトに保存したり、公開フォーラムに投稿したりしないでください。URL 署名シークレットが第三者に知られると、お客様の ID を利用してリクエストが偽装される可能性があります。

Cloud Console のこのページで URL 署名シークレットを取得できます。重要: プレミアムプランの購入時に作成されたプロジェクトを選択してください。

または、次の手順で URL 署名シークレットを表示します。

Cloud Console に移動します。
プロジェクトのプルダウンをクリックし、プレミアムプランの購入時に作成されたプロジェクトを選択します。プロジェクト名は、Google Maps API for Business、Google Maps for Work、または Google Maps で始まります。
[ダッシュボード] ページの API リストで、Google Maps Platform の名前をクリックします。[概要] タブが開き、この API の詳細が表示されます。
[URL 署名シークレット] タブをクリックします。

新しい URL 署名シークレットを取得するには、[シークレットを再生成] をクリックします。古いシークレットは、新しいシークレットを生成してから 24 時間で期限切れになります。24 時間を経過した後は、古いシークレットを含むリクエストが機能しなくなります。

ステップ 2: デジタル署名を生成する

リクエストのデジタル署名を作成する方法については、API キーを使用してデジタル署名を生成するをご覧ください。

クライアント ID とデジタル署名を使用した認証

注: これまで API キーを使用してリクエストを認証しており、今後はクライアント ID による認証に切り替える場合は、API を読み込む前に key パラメータを削除する必要があります。クライアント ID と API キーが両方追加されていると、API の読み込みに失敗します。

クライアント ID と暗号鍵について

Google Maps Platform プレミアムプランライセンスをご購入いただくと、お客様のクライアント ID と秘密暗号鍵が記載されたウェルカムメールが届きます。

クライアント ID を使用して、Google Maps Platform プレミアムプランの特別な機能にアクセスします。以下のサンプルコードでは、YOUR_CLIENT_ID を、ウェルカムメールに記載されているクライアント ID に置き換えます。クライアント ID はすべて、「gme-」という文字列で始まります。
秘密暗号鍵を使用して、一意のデジタル署名を生成します。次のサンプルコードでは、SIGNATURE を一意のデジタル署名に置き換えます。詳しくは、クライアント ID を使用してデジタル署名を生成するをご覧ください。

    <img src="https://maps.googleapis.com/maps/api/staticmap
      ?center=-15.800513,-47.91378
      &zoom=11
      &size=300x300
      &client=YOUR_CLIENT_ID
      &signature=SIGNATURE">

クライアント ID または秘密の暗号鍵を紛失した場合は、Google Cloud Console にログインし、ページ左側で [Google Maps Platform] > [認証情報] > [クライアント ID] の順に選択して取得します。

レポート用のオプションのパラメータ

クライアント ID を使用して API 認証を行う場合、必要であれば次のパラメータを使用できます。

channel: 異なるチャネルごとに情報をグループ化することで、より詳細なレポートを生成できます。詳しくは、プレミアムプランのレポートをご覧ください。

デジタル署名を生成する

リクエストのデジタル署名を作成する方法については、クライアント ID を使用してデジタル署名を生成するをご覧ください。

デジタル署名

デジタル署名の仕組み

デジタル署名は、Google Cloud Console で取得できる暗号 URL 署名シークレットを使用して生成されます。シークレット（秘密鍵）は URL 用修正 Base64 でエンコードされます。このシークレットはお客様と Google の間で共有され、お客様の API キーに固有の情報です。

デジタル署名は、API キーまたはクライアント ID を使用して生成できます。

API キーを使用してデジタル署名を生成する

次の手順に沿って、API キーと組み合わせて使用するデジタル署名を生成します。

署名なしでリクエスト URL を作成します。その際、key パラメータに API キーを指定してください。標準以外の文字は URL エンコードする必要があります。次に例を示します。

https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&key=YOUR_API_KEY

注: すべての Google サービスで、（暗黙的に ASCII を含む）UTF-8 文字エンコードを使用する必要があります。アプリケーションで他の文字セットを使用する場合は、UTF-8 に基づいて URL を作成し、適切に URL エンコードされるようにしてください。
パスとクエリのみを残して、リクエストのドメイン部分を削除します。

/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&key=YOUR_API_KEY
URL 用修正 Base64 でエンコードされた URL 署名シークレットを Cloud Console から取得し、HMAC-SHA1 アルゴリズムを使用して上記の URL に署名します（URL 署名シークレットを取得するをご覧ください）。

場合によっては、シークレットを元のバイナリ形式にデコードする必要があります。ほとんどの暗号ライブラリでは、署名がバイナリ形式で生成されます。

注: URL 用修正 Base64 では、標準 Base64 の + 文字と / 文字がそれぞれ - と _ に置き換えられます。したがって、これらの Base64 署名を URL エンコードする必要がありません。
生成されたバイナリ署名を URL 用修正 Base64 でエンコードし、URL に指定して渡せるように変換します。
この署名をリクエスト URL の signature パラメータに追加します。次に例を示します。

https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&key=YOUR_API_KEY&signature=BASE64_SIGNATURE

サーバー側のコードを使用して URL 署名を実装する方法については、URL 署名のサンプルコードをご覧ください。

今すぐ URL に署名するには、以下に URL と URL 署名シークレットを入力します。入力する URL は、手順 1 で説明した形式に従い、さらに URL エンコードされている必要があります。

クライアント ID によるデジタル署名の生成

client パラメータを使用して Static Maps API をリクエストする場合は、デジタル signature も必要になります。これは、ウェルカムメールに記載されている秘密暗号鍵を使って生成されます。

署名プロセスでは、暗号化アルゴリズムを使用してこの鍵と URL を結合し、一意の署名が生成されます。この一意の署名により、お客様のクライアント ID を使用してリクエストを生成するサイトは、いずれも許可されたサイトであることがわかります。また、署名は URL ごとに異なるため、クライアント ID を使用するリクエストを変更するには、必ず新しい署名を生成する必要があります。

秘密暗号鍵

URL の署名で必要となる秘密暗号鍵はクライアント ID を使用して発行され、お客様と Google が共有する「秘密鍵」です。この署名鍵はお客様だけのものであり、お客様のクライアント ID に関連付けられています。そのため、署名鍵は厳重に保管する必要があります。この鍵をリクエストに追加して送信したり、ウェブサイトに保存したり、公開フォーラムに投稿したりしないでください。この署名鍵が第三者に知られると、お客様の ID を利用してリクエストが偽装される可能性があります。

注: この秘密の暗号署名鍵は、Cloud Console で発行される API キーと同じではありません。

秘密暗号鍵を紛失した場合は、Cloud Console にログインし、[Google Maps Platform] > [認証情報] > [クライアント ID] で取得します。

クライアント ID を使用したデジタル署名の生成

無効な署名を使用して Static Maps API へのアクセスを試みると、HTTP 403 (Forbidden) エラーが発生します。URL 署名を使用するようにアプリケーションを変更するときは、署名をテストして、有効なリクエストが送信されることを確認してください。まず、元の URL が有効かどうかをテストし、さらに正しい署名が生成されるかどうかテストします。

次の手順でリクエストのデジタル署名を作成します。

署名なしでリクエスト URL を作成します。必ず client パラメータを追加してください。標準以外の文字は URL エンコードする必要があります。

https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&client=clientID

注: すべての Google サービスで、（暗黙的に ASCII を含む）UTF-8 文字エンコードを使用する必要があります。アプリケーションで他の文字セットを使用する場合は、UTF-8 に基づいて URL を作成し、適切に URL エンコードしてください。
パスとクエリのみを残して、リクエストのドメイン部分を削除します。

/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&client=clientID
URL 用修正 Base64 でエンコードされた秘密鍵を取得し、HMAC-SHA1 アルゴリズムを使用して上記の URL に署名します。場合によっては、この鍵を元のバイナリ形式にデコードする必要があります。ほとんどの暗号ライブラリでは、署名がバイナリ形式で生成されます。

注: URL 用修正 Base64 では、標準 Base64 の + 文字と / 文字がそれぞれ - と _ に置き換えられます。したがって、これらの Base64 署名を URL エンコードする必要はありません。
生成されたバイナリ署名を URL 用修正 Base64 でエンコードし、URL に指定して渡せるように変換します。
この署名を URL の signature パラメータに追加します。

https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&client=clientID&signature=base64signature

サーバー側のコードを使用して URL 署名を実装する方法については、URL 署名のサンプルコードをご覧ください。

URL 署名のサンプルコード

以下のセクションでは、サーバー側のコードを使用して URL 署名を実装する方法を説明します。暗号鍵をユーザーに知られないようにするため、URL は常にサーバー側で署名してください。

Python

次の例では、標準の Python ライブラリを使用して URL に署名します（サンプルコードをダウンロード）。

#!/usr/bin/python
# -*- coding: utf-8 -*-
""" Signs a URL using a URL signing secret """

import hashlib
import hmac
import base64
import urllib.parse as urlparse

def sign_url(input_url=None, secret=None):
    """ Sign a request URL with a URL signing secret.
      Usage:
      from urlsigner import sign_url
      signed_url = sign_url(input_url=my_url, secret=SECRET)
      Args:
      input_url - The URL to sign
      secret    - Your URL signing secret
      Returns:
      The signed request URL
  """

    if not input_url or not secret:
        raise Exception("Both input_url and secret are required")

    url = urlparse.urlparse(input_url)

    # We only need to sign the path+query part of the string
    url_to_sign = url.path + "?" + url.query

    # Decode the private key into its binary format
    # We need to decode the URL-encoded private key
    decoded_key = base64.urlsafe_b64decode(secret)

    # Create a signature using the private key and the URL-encoded
    # string using HMAC SHA1. This signature will be binary.
    signature = hmac.new(decoded_key, str.encode(url_to_sign), hashlib.sha1)

    # Encode the binary signature into base64 for use within a URL
    encoded_signature = base64.urlsafe_b64encode(signature.digest())

    original_url = url.scheme + "://" + url.netloc + url.path + "?" + url.query

    # Return signed URL
    return original_url + "&signature=" + encoded_signature.decode()

if __name__ == "__main__":
    input_url = input("URL to Sign: ")
    secret = input("URL signing secret: ")
    print("Signed URL: " + sign_url(input_url, secret))

Java

次の例では、JDK 1.8 以降で利用可能な java.util.Base64 クラスを使用します。これより古いバージョンでは、Apache Commons などを使用する必要があります（サンプルコードをダウンロード）。

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;  // JDK 1.8 only - older versions may need to use Apache Commons or similar.
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class UrlSigner {

  // Note: Generally, you should store your private key someplace safe
  // and read them into your code

  private static String keyString = "YOUR_PRIVATE_KEY";

  // The URL shown in these examples is a static URL which should already
  // be URL-encoded. In practice, you will likely have code
  // which assembles your URL from user or web service input
  // and plugs those values into its parameters.
  private static String urlString = "YOUR_URL_TO_SIGN";

  // This variable stores the binary key, which is computed from the string (Base64) key
  private static byte[] key;

  public static void main(String[] args) throws IOException,
    InvalidKeyException, NoSuchAlgorithmException, URISyntaxException {

    BufferedReader input = new BufferedReader(new InputStreamReader(System.in));

    String inputUrl, inputKey = null;

    // For testing purposes, allow user input for the URL.
    // If no input is entered, use the static URL defined above.
    System.out.println("Enter the URL (must be URL-encoded) to sign: ");
    inputUrl = input.readLine();
    if (inputUrl.equals("")) {
      inputUrl = urlString;
    }

    // Convert the string to a URL so we can parse it
    URL url = new URL(inputUrl);

    // For testing purposes, allow user input for the private key.
    // If no input is entered, use the static key defined above.
    System.out.println("Enter the Private key to sign the URL: ");
    inputKey = input.readLine();
    if (inputKey.equals("")) {
      inputKey = keyString;
    }

    UrlSigner signer = new UrlSigner(inputKey);
    String request = signer.signRequest(url.getPath(),url.getQuery());

    System.out.println("Signed URL :" + url.getProtocol() + "://" + url.getHost() + request);
  }

  public UrlSigner(String keyString) throws IOException {
    // Convert the key from 'web safe' base 64 to binary
    keyString = keyString.replace('-', '+');
    keyString = keyString.replace('_', '/');
    System.out.println("Key: " + keyString);
    // Base64 is JDK 1.8 only - older versions may need to use Apache Commons or similar.
    this.key = Base64.getDecoder().decode(keyString);
  }

  public String signRequest(String path, String query) throws NoSuchAlgorithmException,
    InvalidKeyException, UnsupportedEncodingException, URISyntaxException {

    // Retrieve the proper URL components to sign
    String resource = path + '?' + query;

    // Get an HMAC-SHA1 signing key from the raw key bytes
    SecretKeySpec sha1Key = new SecretKeySpec(key, "HmacSHA1");

    // Get an HMAC-SHA1 Mac instance and initialize it with the HMAC-SHA1 key
    Mac mac = Mac.getInstance("HmacSHA1");
    mac.init(sha1Key);

    // compute the binary signature for the request
    byte[] sigBytes = mac.doFinal(resource.getBytes());

    // base 64 encode the binary signature
    // Base64 is JDK 1.8 only - older versions may need to use Apache Commons or similar.
    String signature = Base64.getEncoder().encodeToString(sigBytes);

    // convert the signature to 'web safe' base 64
    signature = signature.replace('+', '-');
    signature = signature.replace('/', '_');

    return resource + "&signature=" + signature;
  }
}

Node JS

次の例では、ネイティブの Node モジュールを使用して URL に署名します（サンプルコードをダウンロード）。

'use strict'

const crypto = require('crypto');
const url = require('url');

/**
 * Convert from 'web safe' base64 to true base64.
 *
 * @param  {string} safeEncodedString The code you want to translate
 *                                    from a web safe form.
 * @return {string}
 */
function removeWebSafe(safeEncodedString) {
  return safeEncodedString.replace(/-/g, '+').replace(/_/g, '/');
}

/**
 * Convert from true base64 to 'web safe' base64
 *
 * @param  {string} encodedString The code you want to translate to a
 *                                web safe form.
 * @return {string}
 */
function makeWebSafe(encodedString) {
  return encodedString.replace(/\+/g, '-').replace(/\//g, '_');
}

/**
 * Takes a base64 code and decodes it.
 *
 * @param  {string} code The encoded data.
 * @return {string}
 */
function decodeBase64Hash(code) {
  // "new Buffer(...)" is deprecated. Use Buffer.from if it exists.
  return Buffer.from ? Buffer.from(code, 'base64') : new Buffer(code, 'base64');
}

/**
 * Takes a key and signs the data with it.
 *
 * @param  {string} key  Your unique secret key.
 * @param  {string} data The url to sign.
 * @return {string}
 */
function encodeBase64Hash(key, data) {
  return crypto.createHmac('sha1', key).update(data).digest('base64');
}

/**
 * Sign a URL using a secret key.
 *
 * @param  {string} path   The url you want to sign.
 * @param  {string} secret Your unique secret key.
 * @return {string}
 */
function sign(path, secret) {
  const uri = url.parse(path);
  const safeSecret = decodeBase64Hash(removeWebSafe(secret));
  const hashedSignature = makeWebSafe(encodeBase64Hash(safeSecret, uri.path));
  return url.format(uri) + '&signature=' + hashedSignature;
}

C#

次の例では、デフォルトの System.Security.Cryptography ライブラリを使用して URL リクエストに署名します。URL セーフバージョンを実装するには、デフォルトの Base64 エンコーディングを変換する必要があります（サンプルコードをダウンロード）。

using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;

namespace SignUrl {

  public struct GoogleSignedUrl {

    public static string Sign(string url, string keyString) {
      ASCIIEncoding encoding = new ASCIIEncoding();

      // converting key to bytes will throw an exception, need to replace '-' and '_' characters first.
      string usablePrivateKey = keyString.Replace("-", "+").Replace("_", "/");
      byte[] privateKeyBytes = Convert.FromBase64String(usablePrivateKey);

      Uri uri = new Uri(url);
      byte[] encodedPathAndQueryBytes = encoding.GetBytes(uri.LocalPath + uri.Query);

      // compute the hash
      HMACSHA1 algorithm = new HMACSHA1(privateKeyBytes);
      byte[] hash = algorithm.ComputeHash(encodedPathAndQueryBytes);

      // convert the bytes to string and make url-safe by replacing '+' and '/' characters
      string signature = Convert.ToBase64String(hash).Replace("+", "-").Replace("/", "_");

      // Add the signature to the existing URI.
      return uri.Scheme+"://"+uri.Host+uri.LocalPath + uri.Query +"&signature=" + signature;
    }
  }

  class Program {

    static void Main() {

      // Note: Generally, you should store your private key someplace safe
      // and read them into your code

      const string keyString = "YOUR_PRIVATE_KEY";

      // The URL shown in these examples is a static URL which should already
      // be URL-encoded. In practice, you will likely have code
      // which assembles your URL from user or web service input
      // and plugs those values into its parameters.
      const  string urlString = "YOUR_URL_TO_SIGN";

      string inputUrl = null;
      string inputKey = null;

      Console.WriteLine("Enter the URL (must be URL-encoded) to sign: ");
      inputUrl = Console.ReadLine();
      if (inputUrl.Length == 0) {
        inputUrl = urlString;
      }

      Console.WriteLine("Enter the Private key to sign the URL: ");
      inputKey = Console.ReadLine();
      if (inputKey.Length == 0) {
        inputKey = keyString;
      }

      Console.WriteLine(GoogleSignedUrl.Sign(inputUrl,inputKey));
    }
  }
}

その他の言語のサンプルコード

その他の言語のサンプルコードは、URL 署名プロジェクトで入手できます。

認証の問題のトラブルシューティング

リクエストの形式が正しくない場合や、署名が無効な場合は、Google Maps Platform から HTTP 403 (Forbidden) エラーが返されます。

URL を個別にトラブルシューティングするときは、URL Signing Debugger を使用すると便利です。このツールにより、URL や、アプリケーションによって生成される署名をすばやく検証できます。

プレミアムプランのお客様が個々の URL をトラブルシューティングするには、Cloud Console にログインし、[リソース] > [Google Maps Platform プレミアムプランのオンラインツール] > [ウェブサービスおよびイメージ API 向け URL Signing Debugger] を選択する方法もあります。