API de Maps Static: Cómo obtener una clave de API y una firma

Nota: El plan premium de Google Maps Platform ya no está disponible para registros o clientes nuevos.

Cómo elegir un método de autenticación

Para usar la API de Maps Static, debes autenticar las solicitudes mediante dos parámetros: una clave de API y una firma digital, o bien un ID de cliente y una firma digital.

El método de autenticación que puedes elegir depende de tu licencia:

  • Los clientes del plan premium pueden usar una clave de API y una firma digital, o bien un ID de cliente y una firma digital.
  • Los clientes con una licencia anterior deben usar un ID de cliente y una firma digital.

¿Tienes el plan premium o una licencia anterior?
Para determinar qué licencia tienes, haz lo siguiente:
> En el Portal de asistencia de Google Cloud, haz clic en Maps: Informe de uso a la izquierda.
> ¿El ID que aparece en la parte superior del informe tiene el siguiente formato?
   gme-[company] & proj-[number] ([type])
Si la respuesta es afirmativa, tienes el plan premium.
De lo contrario, tienes una licencia anterior (API de Google Maps for Work o API de Google Maps for Business).

Cuando debas decidir el método de autenticación que utilizarás, ten en cuenta lo siguiente:

  • Clave de API (plan premium): Si usas una clave de API para autenticar las solicitudes, puedes hacer lo siguiente:
  • ID de cliente (plan premium o licencia anterior): Si usas tu ID de cliente para autenticar las solicitudes, puedes hacer lo siguiente:
    • Agregar el parámetro channel a las solicitudes para poder ver informes de uso más detallados
    • Consultar informes de uso con datos de más de 30 días de antigüedad en el Portal de asistencia de Google Cloud
    • Usar las herramientas de Maps Analytics para la API de Maps JavaScript

Autenticación con una clave de API y una firma digital

Cómo crear claves de API

Debes tener, al menos, una clave de API asociada a tu proyecto.

Para obtener una clave de API, haz lo siguiente:

  1. Ve a Google Cloud Platform Console.
  2. Haz clic en el menú desplegable de proyectos y selecciona el que se creó cuando compraste el plan premium. El nombre del proyecto comienza con API de Google Maps for Business, Google Maps for Work o Google Maps.
  3. Nota: Para tener acceso completo a las funciones de su plan, los clientes premium deben usar el proyecto asociado con su cuenta premium. Cuando compraste tu licencia, recibiste el nombre de tu elemento premium en el siguiente formato: gme-[company] & proj-[number] ([type]). Para asegurarte de utilizar el proyecto correcto, accede a la consola como propietario mediante console.cloud.google.com/project/number (reemplaza number por tu número de proyecto). Puedes encontrar el propietario del proyecto en tu carta de bienvenida.

  4. Haz clic en el botón de menú  y selecciona API y servicios > Credenciales.
  5. En la página Credenciales, haz clic en Crear credenciales > Clave de API.
    El diálogo Se creó la clave de API mostrará la clave de API que acabas de crear (una string encriptada).
  6. Haz clic en Cerrar.
    La nueva clave de API aparecerá en la página Credenciales debajo de Claves de API.

Cómo agregar la clave de API a tu solicitud

Debes incluir una clave de API con cada solicitud a la API de Maps Static. En el siguiente ejemplo, reemplaza YOUR_API_KEY por tu clave de API.

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

Cómo restringir las claves de API

Restringir las claves de API agrega seguridad a tu aplicación, ya que garantiza que solo se realicen solicitudes autorizadas con tu clave de API. Te recomendamos enfáticamente que sigas las instrucciones si deseas configurar restricciones para tus claves de API. Para obtener más información, consulta Prácticas recomendadas sobre las claves de API.

Para restringir una clave de API, sigue estos pasos:

  1. En GCP Console, en la página del selector de proyectos, selecciona o crea un proyecto de Google Cloud en el que deseas agregar una clave de API.

    Ir a la página del selector de proyectos

  2. Ve a la página API y servicios > Credenciales.

    Ir a la página Credenciales

  3. Selecciona la clave de API para la que deseas establecer una restricción. Aparecerá la página de propiedades de la clave de API.
  4. En Restricciones de clave, establece las siguientes restricciones:
    • Restricciones de aplicaciones:
      1. Para aceptar las solicitudes de la lista del sitio web que proporcionas, selecciona URL de referencia HTTP (sitios web) en la lista de Restricciones de aplicaciones.
      2. Especifica uno o más sitios web con URL de referencia. Por ejemplo, *.google.com acepta todos los sitios que terminan en google.com, como https://developers.google.com.

        Nota: Las URL de referencia file:// necesitan que se agregue una representación especial a la restricción de clave. La parte "file://" debe reemplazarse por "__file_url__" antes de agregarse a la restricción. Por ejemplo, "file:///path/to/" debe tener el formato "__file_url__//path/to/*". Después de habilitar las URL de referencia file://, se recomienda que revises tu uso periódicamente para asegurarte de que coincida con tus expectativas.

    • Restricciones de API:
      1. Haz clic en Restringir clave.
      2. Selecciona API de Maps Static en el menú desplegable Seleccionar API.
        (Si la API de Maps Static no aparece en la lista, debes habilitarla).
  5. Para finalizar los cambios, haz clic en Guardar.

Cómo generar una firma digital

Las solicitudes a la API de Maps Static que usen un parámetro key, con una clave de API, también deberán incluir un parámetro signature, con una firma digital que debes generar mediante un secreto de firma de URL compartido. Tu secreto compartido está disponible en Google Cloud Platform Console.

El proceso de firma usa un algoritmo de encriptación para combinar la URL y tu secreto compartido. La firma única resultante permite que nuestros servidores verifiquen que los sitios que generen solicitudes con tu clave de API estén autorizados para hacerlo.

Para crear una firma digital, se requieren dos pasos:

Paso 1: Obtén tu secreto de firma de URL

Tu secreto criptográfico de firma de URL está disponible en Google Cloud Platform Console. El secreto, también conocido como una clave privada, está codificado en un sistema Base64 modificado para URL. A ese secreto lo comparten tú y Google, y es exclusivo de tu clave de API. Protege tu secreto de firma de URL. No debe pasarse en solicitudes, almacenarse en sitios web ni publicarse en foros públicos. Cualquier persona que obtenga este secreto de firma de URL podría falsificar solicitudes usando tu identidad.

Puedes hacer clic en este vínculo para ir directamente a la página de GCP Console que contiene tu secreto de firma de URL. Importante: Haz clic en el menú desplegable de proyectos y selecciona el proyecto que se creó cuando compraste el plan premium.

También puedes seguir estos pasos para ver tu secreto de firma de URL:

  1. Ve a Google Cloud Platform Console.
  2. Haz clic en el menú desplegable de proyectos y selecciona el que se creó cuando compraste el plan premium. El nombre del proyecto comienza con API de Google Maps for Business, Google Maps for Work o Google Maps.
  3. En la lista de API de la página Panel, haz clic en el nombre de la API de Maps Static. Se mostrarán los detalles de la API, y la pestaña Descripción general estará abierta.
  4. Haz clic en la pestaña Secreto de firma de URL.

Para obtener un nuevo secreto de firma de URL, haz clic en Volver a generar secreto. El secreto anterior vence 24 horas después de que generes uno nuevo. Una vez que pase este período, las solicitudes que contengan el secreto anterior ya no funcionarán.

Paso 2: Genera una firma digital

Si deseas crear una firma digital para tu solicitud, consulta Cómo generar una firma digital con una clave de API.

Autenticación con un ID de cliente y una firma digital

Conceptos básicos sobre tu ID de cliente y la clave criptográfica

Cuando compres tu licencia del plan premium de Google Maps Platform, recibirás un correo electrónico de bienvenida de Google con tu ID de cliente y tu clave criptográfica privada.

  • Tu ID de cliente se usa para acceder a las funciones especiales del plan premium de Google Maps Platform. En la muestra que aparece a continuación, reemplaza YOUR_CLIENT_ID por el ID de cliente que te enviamos en el correo electrónico de bienvenida. Todos los ID de cliente comienzan con un prefijo gme-.

  • Tu clave criptográfica privada se usa para generar una firma digital única. En la muestra de código que aparece a continuación, reemplaza SIGNATURE por tu firma digital única. Para obtener más información, consulta Cómo generar una firma digital con un ID de cliente.

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

Si perdiste tu ID de cliente o clave criptográfica privada, y deseas recuperarlos, accede al Portal de asistencia de Google Cloud y haz clic en el vínculo Maps: Administrar ID de cliente que aparece a la izquierda de la página.

Parámetro opcional para los informes

Cuando uses el ID de cliente para autenticar la API, también contarás con el siguiente parámetro opcional:

  • channel se usa para que tus informes sean más detallados, ya que permite agrupar en ellos diferentes canales por separado. Consulta la descripción general de los informes del plan premium para obtener más información.

Cómo generar una firma digital

Si deseas crear una firma digital para tu solicitud, consulta Cómo generar una firma digital con un ID de cliente.

Firmas digitales

Cómo funcionan las firmas digitales

Las firmas digitales se generan mediante un secreto criptográfico de firma de URL, que está disponible en Google Cloud Platform Console. El secreto, también conocido como una clave privada, está codificado en un sistema Base64 modificado para URL. A ese secreto lo comparten tú y Google, y es exclusivo de tu clave de API.

El proceso de firma usa un algoritmo de encriptación para combinar la URL y tu secreto compartido. La firma única resultante permite que nuestros servidores verifiquen que los sitios que generen solicitudes con tu clave de API estén autorizados para hacerlo.

Puedes generar una firma digital con una clave de API o un ID de cliente.

Cómo generar una firma digital con una clave de API

Sigue estos pasos a fin de crear una firma digital para usarla junto con una clave de API:

  1. Crea la URL de la solicitud sin la firma y asegúrate de incluir tu clave de API en el parámetro key. Ten en cuenta que debes codificar en formato URL los caracteres que no sean estándares. Por ejemplo:

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

    Nota: Todos los servicios de Google deben contar con codificación de caracteres UTF-8 (que implícitamente incluye ASCII). Si tus aplicaciones funcionan con otros grupos de caracteres, asegúrate de que creen URL con caracteres UTF-8 y que los codifiquen en formato URL correctamente.

  2. Extrae la parte del dominio de la solicitud y deja solo la ruta de acceso y la consulta:

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

  3. Recupera tu secreto de firma de URL, que está codificado en un sistema Base64 modificado para URL, desde Google Cloud Platform Console, y firma la URL anterior con el algoritmo HMAC-SHA1 (consulta Cómo obtener tu secreto de firma de URL).

    Podrías necesitar decodificar tu secreto a su formato binario original. Ten en cuenta que, en la mayoría de las bibliotecas criptográficas, la firma resultante estará en formato binario.

    Nota: El sistema Base64 modificado para URL reemplaza los caracteres + y / del sistema Base64 estándar por - y _ respectivamente, de modo que ya no es necesario codificar en formato URL estas firmas de Base64.

  4. Codifica la firma binaria resultante mediante el sistema Base64 modificado para URL a fin de convertirla en un elemento que se pueda pasar dentro de una URL.

  5. Agrega la firma resultante a la URL de la solicitud dentro de un parámetro signature. Por ejemplo:

    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

Si deseas ver muestras que ilustren diferentes maneras de implementar la firma de URL con código del servidor, consulta Código de muestra para firmas de URL.

Para firmar una URL ahora, ingresa tu URL y tu secreto de firma de URL a continuación. La URL debe tener el formato descrito en el paso 1 anterior y debe estar codificada en formato URL.

Cómo generar una firma digital con un ID de cliente

Las solicitudes a la API de Maps Static con el parámetro client también requieren una firma (signature) digital, que se genera con la clave criptográfica privada que te proporcionamos en tu correo electrónico de bienvenida.

El proceso de firma combina una URL y la clave mediante un algoritmo de encriptación. La firma única resultante permite a nuestros servidores verificar que los sitios que generen solicitudes con tu ID de cliente estén autorizados para hacerlo. La firma también es exclusiva de cada URL, lo que garantiza que las solicitudes que usen tu ID de cliente no se puedan modificar sin generar una firma nueva.

Tu clave criptográfica privada

Tu clave criptográfica privada para firmas de URL se generará con tu ID de cliente y es una "clave secreta compartida" entre tú y Google. Esta clave para firmas es solo tuya y exclusiva de tu ID de cliente. Por esta razón, debes asegurarte de que esté protegida. Esta clave no debe pasarse en ninguna solicitud, almacenarse en sitios web ni publicarse en foros públicos. Si alguien la obtiene, podría realizar solicitudes falsas con tu identidad.

Nota: Esta clave criptográfica privada para firmas no es igual a las claves de API que emite Google Cloud Platform Console.

Si perdiste tu clave criptográfica privada, accede al Portal de asistencia de Google Cloud y haz clic en Maps: Administrar ID de cliente para recuperarla.

Cómo generar una firma digital con un ID de cliente

Si intentas acceder a la API de Maps Static con una firma no válida, se mostrará el error HTTP 403 (Prohibido). A medida que conviertas tus aplicaciones para que usen firmas de URL, prueba las firmas a fin de asegurarte de que inicien una solicitud válida. Primero debes probar si la URL original es válida y si se generan las firmas correctas.

Sigue estos pasos para crear una firma digital para tu solicitud:

  1. Crea la URL de la solicitud sin la firma y asegúrate de incluir el parámetro client. Ten en cuenta que cualquier carácter no estándar deberá estar codificado en formato URL:

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

    Nota: Todos los servicios de Google deben contar con codificación de caracteres UTF-8 (que implícitamente incluye ASCII). Si tus aplicaciones funcionan con otros grupos de caracteres, asegúrate de que creen URL con caracteres UTF-8 y que los codifiquen en formato URL correctamente.

  2. Extrae la parte del dominio de la solicitud y deja solo la ruta de acceso y la consulta:

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

  3. Recupera tu clave privada, que está codificada en un sistema Base64 modificado para URL, y firma la URL anterior con el algoritmo HMAC-SHA1. Es posible que debas decodificar esta clave a su formato binario original. Ten en cuenta que, en la mayoría de las bibliotecas criptográficas, la firma resultante estará en formato binario.

    Nota: El sistema Base64 modificado para URL reemplaza los caracteres + y / del sistema Base64 estándar por - y _ respectivamente, de modo que ya no es necesario codificar estas firmas de Base64 en formato URL.

  4. Codifica la firma binaria resultante mediante el sistema Base64 modificado para URL a fin de convertirla en un elemento que se pueda pasar dentro de una URL.

  5. Adjunta esta firma a la URL dentro de un parámetro signature:

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

Si deseas ver muestras que ilustren diferentes maneras de implementar la firma de URL con código del servidor, consulta Código de muestra para firmas de URL.

Para firmar una URL ahora, ingresa tu URL y tu secreto de firma de URL a continuación. La URL debe tener el formato descrito en el paso 1 anterior y debe estar codificada en formato URL.

Código de muestra para la firma de URL

En las siguientes secciones, se muestra cómo implementar una firma de URL con un código del servidor. Siempre debes firmar las URL en el servidor para evitar exponer tu clave criptográfica a los usuarios.

Python

El siguiente ejemplo usa bibliotecas Python estándares para firmar una URL (descarga el código).

#!/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

El siguiente ejemplo usa la clase java.util.Base64 disponible desde JDK 1.8. Es posible que las versiones anteriores necesiten usar Apache Commons o similares (descarga el código).

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

El siguiente ejemplo usa módulos de Node nativos para firmar una URL (descarga el código).

'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#

El siguiente ejemplo usa la biblioteca System.Security.Cryptography predeterminada para firmar una solicitud de URL. Ten en cuenta que debemos convertir la codificación Base64 predeterminada para implementar una versión compatible con URL (descarga el código).

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));
    }
  }
}

Ejemplos en otros lenguajes

Encontrarás ejemplos que incluyen más lenguajes en el proyecto de firma de URL.

Cómo solucionar problemas de autenticación

Si tu solicitud no tiene el formato correcto o proporciona una firma no válida, la API de Maps Static muestra un error HTTP 403 (Forbidden).

Para solucionar problemas relacionados con URL individuales, puedes usar la herramienta URL Signing Debugger. Este depurador te permitirá validar rápidamente una URL y la firma que generó tu aplicación.

Como alternativa, si los clientes del plan premium desean solucionar problemas de URL individuales, pueden acceder al Portal de asistencia de Google Cloud y seleccionar Recursos > Herramientas en línea del plan premium de Google Maps Platform > URL Signing Debugger para API de imagen y servicio web.