Comenzar

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Los desarrolladores pueden usar la API de Google Ad Manager para compilar aplicaciones que administran inventarios, crean pedidos, extraen informes y mucho más.

La API de Ad Manager usa SOAP. Para ayudarlo a comenzar, ofrecemos bibliotecas cliente para Java, .NET, Python, PHP y Ruby. Para realizar tu primera solicitud a la API, sigue los pasos que se indican a continuación.

Cómo obtener acceso a una red de Ad Manager

Si aún no tienes una, regístrate para obtener una cuenta de Ad Manager. También puedes crear una red de prueba si deseas probar la API en un entorno separado. Ten en cuenta que no necesitas una cuenta de AdSense para realizar pruebas.

Toma nota del código de red. Encontrarás esto en la URL cuando accedas a tu red. Por ejemplo, en la URL https://admanager.google.com/1234#home, 1234 es tu código de red.

Crear credenciales de autenticación

Debe autenticar todas las solicitudes a la API de Ad Manager con OAuth2. En los siguientes pasos, se describe el caso práctico sencillo de acceder a tus propios datos de Ad Manager. Para obtener más detalles y otras opciones, consulta Autenticación.

  1. Abre la página de credenciales de la Consola de API de Google.
  2. En el menú del proyecto, elige Crear proyecto, ingresa un nombre para el proyecto y, de manera opcional, edita el ID del proyecto proporcionado. Haz clic en Crear.
  3. En la página Credenciales, selecciona Crear credenciales y, luego, Clave de cuenta de servicio.
  4. Selecciona Cuenta de servicio nueva y selecciona JSON como el tipo de clave.
  5. Haz clic en Crear para descargar un archivo que contiene una clave privada.

Cómo configurar su red de Ad Manager

  1. Accede a Google Ad Manager.
  2. En la barra lateral, haga clic en Administrador > Configuración global.
  3. En Configuración general, en Acceso a la API, haz clic en el control deslizante para Habilitar.
  4. Haz clic en el botón Guardar en la parte inferior de la página.

Configure su cliente

Descargue una de las bibliotecas cliente de Ad Manager. Las bibliotecas ofrecen funciones de wrapper y características que facilitan y aceleran el desarrollo de aplicaciones.

Las siguientes pestañas proporcionan guías de inicio rápido para codificar en cada uno de los lenguajes para los que hay una biblioteca cliente.

Java

A continuación, se muestra un ejemplo básico que muestra cómo usar la biblioteca cliente de Java. Para obtener información de uso más detallada, consulta el archivo README en la distribución de la biblioteca cliente.

  1. Configura tus credenciales

    Ejecuta el siguiente comando en una shell:

    curl https://raw.githubusercontent.com/googleads/googleads-java-lib/master/examples/admanager_axis/src/main/resources/ads.properties -o ~/ads.properties
    Abre el archivo ~/ads.properties y propaga los siguientes campos:
    [...]
    api.admanager.applicationName=INSERT_APPLICATION_NAME_HERE
    api.admanager.jsonKeyFilePath=INSERT_PATH_TO_JSON_KEY_FILE_HERE
    api.admanager.networkCode=INSERT_NETWORK_CODE_HERE
    [...]
  2. Especifica dependencias

    Edita el archivo pom.xml y agrega lo siguiente a la etiqueta dependencies. Puedes encontrar el número de versión más reciente en GitHub.

    <dependency>
      <groupId>com.google.api-ads</groupId>
      <artifactId>ads-lib</artifactId>
      <version>RELEASE</version>
    </dependency>
    <dependency>
      <groupId>com.google.api-ads</groupId>
      <artifactId>dfp-axis</artifactId>
      <version>RELEASE</version>
    </dependency>

  3. Escribe código y haz una solicitud.

    import com.google.api.ads.common.lib.auth.OfflineCredentials;
    import com.google.api.ads.common.lib.auth.OfflineCredentials.Api;
    import com.google.api.ads.admanager.axis.factory.AdManagerServices;
    import com.google.api.ads.admanager.axis.v202211.Network;
    import com.google.api.ads.admanager.axis.v202211.NetworkServiceInterface;
    import com.google.api.ads.admanager.lib.client.AdManagerSession;
    import com.google.api.client.auth.oauth2.Credential;
    
    public class App {
      public static void main(String[] args) throws Exception {
        Credential oAuth2Credential = new OfflineCredentials.Builder()
            .forApi(Api.AD_MANAGER)
            .fromFile()
            .build()
            .generateCredential();
    
        // Construct an AdManagerSession.
        AdManagerSession session = new AdManagerSession.Builder()
            .fromFile()
            .withOAuth2Credential(oAuth2Credential)
            .build();
    
        // Construct a Google Ad Manager service factory, which can only be used once per
        // thread, but should be reused as much as possible.
        AdManagerServices adManagerServices = new AdManagerServices();
    
        // Retrieve the appropriate service
        NetworkServiceInterface networkService = adManagerServices.get(session,
            NetworkServiceInterface.class);
    
        // Make a request
        Network network = networkService.getCurrentNetwork();
    
        System.out.printf("Current network has network code '%s' and display" +
            " name '%s'.%n", network.getNetworkCode(), network.getDisplayName());
      }
    }
    

Python

Aquí tienes un ejemplo básico que muestra cómo usar la biblioteca cliente de Python. La biblioteca cliente de Python es compatible con Python v3.6+. Para obtener información de uso más detallada, consulta el archivo README en la distribución de la biblioteca cliente.

  1. Instala la biblioteca y configura tus credenciales.

    Ejecuta los siguientes comandos en una shell:

    pip install googleads
    curl https://raw.githubusercontent.com/googleads/googleads-python-lib/master/googleads.yaml \
         -o ~/googleads.yaml
    
  2. Configura tu archivo ~/googleads.yaml.

    Complete los siguientes campos:

    ad_manager:
      application_name: INSERT_APPLICATION_NAME_HERE
      network_code: INSERT_NETWORK_CODE_HERE
      path_to_private_key_file: INSERT_PATH_TO_FILE_HERE
    
  3. Ejecuta un poco de código y realiza una solicitud.
    # Import the library.
    from googleads import ad_manager
    
    # Initialize a client object, by default uses the credentials in ~/googleads.yaml.
    client = ad_manager.AdManagerClient.LoadFromStorage()
    
    # Initialize a service.
    network_service = client.GetService('NetworkService', version='v202211')
    
    # Make a request.
    current_network = network_service.getCurrentNetwork()
    
    print("Current network has network code '%s' and display name '%s'." %
            (current_network['networkCode'], current_network['displayName']))
    

PHP

A continuación, se muestra un ejemplo básico que muestra cómo usar la biblioteca cliente de PHP.

  1. Instala la biblioteca y configura tus credenciales.

    Ejecuta los siguientes comandos en una shell para instalar la biblioteca cliente y descarga el archivo adsapi_php.ini en tu directorio principal:

    composer require googleads/googleads-php-lib
    curl https://raw.githubusercontent.com/googleads/googleads-php-lib/master/examples/AdManager/adsapi_php.ini -o ~/adsapi_php.ini
  2. Configura el archivo ~/adsapi_php.ini.

    Complete los siguientes campos:

    [AD_MANAGER]
    networkCode = "INSERT_NETWORK_CODE_HERE"
    applicationName = "INSERT_APPLICATION_NAME_HERE"
    
    [OAUTH2]
    jsonKeyFilePath = "INSERT_ABSOLUTE_PATH_TO_OAUTH2_JSON_KEY_FILE_HERE"
    scopes = "https://www.googleapis.com/auth/dfp"
    
  3. Ejecuta algún código y realiza una solicitud.
    <?php
    require 'vendor/autoload.php';
    use Google\AdsApi\AdManager\AdManagerSession;
    use Google\AdsApi\AdManager\AdManagerSessionBuilder;
    use Google\AdsApi\AdManager\v202211\ApiException;
    use Google\AdsApi\AdManager\v202211\ServiceFactory;
    use Google\AdsApi\Common\OAuth2TokenBuilder;
    
    // Generate a refreshable OAuth2 credential for authentication.
    $oAuth2Credential = (new OAuth2TokenBuilder())
        ->fromFile()
        ->build();
    // Construct an API session configured from a properties file and the OAuth2
    // credentials above.
    $session = (new AdManagerSessionBuilder())
        ->fromFile()
        ->withOAuth2Credential($oAuth2Credential)
        ->build();
    
    // Get a service.
    $serviceFactory = new ServiceFactory();
    $networkService = $serviceFactory->createNetworkService($session);
    
    // Make a request
    $network = $networkService->getCurrentNetwork();
    printf(
        "Network with code %d and display name '%s' was found.\n",
        $network->getNetworkCode(),
        $network->getDisplayName()
    );
    

.NET

A continuación, se muestra un ejemplo básico que muestra cómo usar la biblioteca cliente de .NET.

  1. Crea un proyecto nuevo

    Abre Visual Studio y crea un proyecto nuevo (es decir, una aplicación de consola).

  2. Agrega referencias de biblioteca obligatorias a tu proyecto

    Agrega una dependencia nuget para Google.Dfp.

  3. Configura tu app.config

    Copia src\App.config al directorio de tu proyecto y agrégalo a tu proyecto. Si tu aplicación tiene su propio archivo App.config, puedes copiar los siguientes nodos en tu archivo App.config:

    • configuración/AdManagerApi
    • configuration/configSections/section[nombre="AdManagerApi"]
    • configuración/sistema.net
  4. Configurar credenciales

    Abre App.config y edita las siguientes claves:

    <add key="ApplicationName" value="INSERT_YOUR_APPLICATION_NAME_HERE" />
    <add key="NetworkCode" value="INSERT_YOUR_NETWORK_CODE_HERE" />
    <add key="OAuth2Mode" value="SERVICE_ACCOUNT" />
    <add key="OAuth2SecretsJsonPath" value="INSERT_OAUTH2_SECRETS_JSON_FILE_PATH_HERE" />
    

  5. Haz una llamada a la biblioteca

    Puedes llamar a la biblioteca como se muestra en el siguiente fragmento de código de C#

    AdManagerUser user = new AdManagerUser();
          using (InventoryService inventoryService = user.GetService<InventoryService>())
                {
                    // Create a statement to select ad units.
                    int pageSize = StatementBuilder.SUGGESTED_PAGE_LIMIT;
                    StatementBuilder statementBuilder =
                        new StatementBuilder().OrderBy("id ASC").Limit(pageSize);
    
                    // Retrieve a small amount of ad units at a time, paging through until all
                    // ad units have been retrieved.
                    int totalResultSetSize = 0;
                    do
                    {
                        AdUnitPage page =
                            inventoryService.getAdUnitsByStatement(statementBuilder.ToStatement());
    
                        // Print out some information for each ad unit.
                        if (page.results != null)
                        {
                            totalResultSetSize = page.totalResultSetSize;
                            int i = page.startIndex;
                            foreach (AdUnit adUnit in page.results)
                            {
                                Console.WriteLine(
                                    "{0}) Ad unit with ID \"{1}\" and name \"{2}\" was found.", i++,
                                    adUnit.id, adUnit.name);
                            }
                        }
    
                        statementBuilder.IncreaseOffsetBy(pageSize);
                    } while (statementBuilder.GetOffset() < totalResultSetSize);
    
                    Console.WriteLine("Number of results found: {0}", totalResultSetSize);
                }
            

Si no quieres establecer tus credenciales en App.config, consulta este artículo de la wiki para conocer otras formas de usar la clase AdManagerUser. Para obtener información más detallada sobre el uso de la biblioteca cliente de .NET, consulta el archivo README. Si quieres desarrollar en .NET sin la biblioteca cliente, consulta el artículo de la wiki de NoClientLibrary.

Ruby

A continuación, se muestra un ejemplo básico que muestra cómo usar la biblioteca cliente de Ruby. La biblioteca cliente de Ruby requiere Ruby 2.1 o una versión posterior.

  1. Instala la gema de Ruby y obtén el archivo de configuración.

    Ejecuta los siguientes comandos en una shell:

    gem install google-dfp-api
    curl https://raw.githubusercontent.com/googleads/google-api-ads-ruby/master/ad_manager_api/ad_manager_api.yml -o ~/ad_manager_api.yml
    

  2. Configura tus credenciales

    Propaga los campos obligatorios en el archivo ~/ad_manager_api.yml. Si aún no tienes un archivo de claves OAuth2, deberás seguir los pasos para crear tus credenciales de OAuth2.

    :authentication:
      :oauth2_keyfile: INSERT_PATH_TO_JSON_KEY_FILE_HERE
      :application_name: INSERT_APPLICATION_NAME_HERE
      :network_code: INSERT_NETWORK_CODE_HERE
    
  3. Escribe código y haz una solicitud.
    # Import the library.
    require 'ad_manager_api'
    
    # Initialize an Ad Manager client instance (uses credentials in ~/ad_manager_api.yml by default).
    ad_manager = AdManagerApi::Api.new
    
    # Get a service instance.
    network_service = ad_manager.service(:NetworkService, :v202211)
    
    # Make a request.
    network = network_service.get_current_network()
    
    puts "The current network is %s (%d)." %
            [network[:display_name], network[:network_code]]
    

Puedes encontrar pasos más detallados para comenzar en el archivo README que se distribuye con la biblioteca cliente de Ruby. Además, consulta nuestra biblioteca de ejemplo completa para Ruby.

Próximos pasos

Cuando tengas una biblioteca cliente en funcionamiento, modifica los ejemplos proporcionados para extenderlos a tus necesidades.

Explora la documentación de referencia para obtener más información sobre la API.

Si necesitas ayuda, visita nuestra página de asistencia.