Cómo conectarse a la API de Bing Webmaster Tools usando Google Colab

Bing Webmaster Tools permite analizar cómo Bing rastrea, indexa y muestra una web en sus resultados de búsqueda. Además de usar la interfaz visual, también se puede acceder a parte de esa información mediante su API.

En este tutorial aprenderás cómo conectar Google Colab con la API de Bing Webmaster Tools para extraer datos de rendimiento como clicks e impresiones. El objetivo es que cualquier persona pueda copiar y pegar los scripts, adaptar sus propios datos y obtener una primera conexión funcional.

Con este tutorial podrás:

Generar una API Key en Bing Webmaster Tools.
Conectarte a la API desde Google Colab.
Comprobar si la conexión funciona.
Descargar datos de clicks e impresiones.
Convertir la respuesta en una tabla.
Guardar o exportar los resultados para analizarlos.

1. Qué es la API de Bing Webmaster Tools

La API de Bing Webmaster Tools permite acceder de forma programática a datos de sitios verificados en Bing Webmaster Tools.

Según la documentación oficial de Microsoft, la API permite consultar información de sitios registrados, incluyendo datos como Rank & Traffic Stats, Link Details, Keyword Details y Crawl Stats. También permite enviar URLs, sitemaps y otros detalles del sitio.

Para acceder a la API existen dos opciones principales:

OAuth 2.0.
API Key.

Microsoft indica que los webmasters pueden usar cualquiera de los dos métodos, aunque OAuth 2.0 aparece como recomendado en la documentación. Para este tutorial se utilizará API Key porque es la forma más simple para empezar desde Colab.

2. Qué necesitas antes de empezar

Antes de abrir Colab, necesitas tener:

Una cuenta en Bing Webmaster Tools.
Una web añadida y verificada en Bing Webmaster Tools.
Una API Key de Bing Webmaster Tools.
Un notebook de Google Colab.
La URL exacta de la propiedad verificada.

La URL de la propiedad es importante. Si en Bing Webmaster Tools tienes verificada la propiedad como https://www.ejemplo.com/, esa misma URL debe usarse en el script. Si usas una variante diferente (sin www, con http, etc.) la API puede devolver error o no encontrar datos.

3. Cómo generar la API Key en Bing Webmaster Tools

Para generar la API Key:

Entra en Bing Webmaster Tools.
Selecciona tu cuenta.
Ve a la sección de configuración.
Busca el apartado de API Access.
Acepta los términos si es la primera vez que accedes.
Haz clic en Generate API Key.
Copia la API Key generada.

Microsoft explica que la API Key se genera para el usuario, no para un sitio específico. Eso significa que la misma API Key puede utilizarse para los sitios que ese usuario tenga verificados en Bing Webmaster Tools.

Importante: no compartas tu API Key públicamente. Si crees que la clave se ha expuesto o comprometido, elimínala y genera una nueva desde Bing Webmaster Tools.

4. Crear un notebook en Google Colab

Abre Google Colab y crea un notebook nuevo. Nombre recomendado: Bing_Webmaster_Tools_API_Colab.

5. Celda 1 — Instalar e importar librerías

La primera celda instala e importa las librerías necesarias: requests para hacer llamadas a la API, pandas para convertir los datos en tablas, re para limpiar fechas y getpass para pegar la API Key sin mostrarla en pantalla.

!pip install -q pandas requests

import requests
import pandas as pd
import re
from getpass import getpass

print("Librerías listas")

6. Celda 2 — Configurar la API Key y la URL del sitio

En esta celda debes introducir tu API Key de Bing Webmaster Tools y la URL exacta de la propiedad verificada. Para no dejar la API Key escrita directamente en el notebook, se usará getpass().

BWT_API_KEY = getpass("Pega tu API Key de Bing Webmaster Tools: ").strip()

# Cambia esta URL por la URL exacta de tu propiedad verificada en Bing Webmaster Tools
BWT_SITE_URL = "https://www.tudominio.com/"

BWT_BASE_URL = "https://ssl.bing.com/webmaster/api.svc/json"

print("Configuración cargada")
print(f"Sitio configurado: {BWT_SITE_URL}")

7. Celda 3 — Crear una función para llamar a la API

Para no repetir código, creamos una función general llamada bwt_get(). Esta función construye la URL del endpoint, añade la API Key, envía la solicitud, oculta la API Key en los prints, revisa si la respuesta fue correcta y devuelve los datos en formato JSON.

def bwt_get(method, params=None):
    """
    Llama a un método JSON de Bing Webmaster Tools API.
    method: nombre del método de la API.
    params: parámetros adicionales de la llamada.
    """
    if params is None:
        params = {}

    params = params.copy()
    params["apikey"] = BWT_API_KEY

    url = f"{BWT_BASE_URL}/{method}"
    response = requests.get(url, params=params, timeout=120)

    # Ocultar la API key en el print para no exponerla en pantalla
    safe_url = response.url.replace(BWT_API_KEY, "API_KEY_OCULTA")
    print(f"Request: {safe_url}")
    print(f"Status: {response.status_code}")

    if response.status_code != 200:
        print("Respuesta de Bing:")
        print(response.text[:2000])
        raise Exception(f"Error en Bing Webmaster API: {response.status_code}")

    data = response.json()

    if isinstance(data, dict) and "d" in data:
        return data["d"]

    return data


print("Función bwt_get lista")

8. Celda 4 — Crear una función para limpiar fechas

Algunas respuestas de Bing pueden devolver fechas en formato tipo /Date(1316156400000-0700)/. Creamos una función que las convierta a formato normal.

def parse_bing_date(value):
    """
    Convierte fechas de Bing tipo /Date(1316156400000-0700)/ a fecha normal.
    """
    if pd.isna(value):
        return None

    value = str(value)
    match = re.search(r"/Date\((\d+)", value)

    if match:
        timestamp_ms = int(match.group(1))
        return pd.to_datetime(timestamp_ms, unit="ms", utc=True).date()

    try:
        return pd.to_datetime(value).date()
    except Exception:
        return None


print("Función parse_bing_date lista")

9. Celda 5 — Convertir la respuesta en DataFrame

La API devuelve datos en JSON. Para analizarlos de forma cómoda, convertimos la respuesta en una tabla de pandas.

def clean_bwt_dataframe(data):
    """
    Convierte una respuesta de Bing Webmaster Tools API en DataFrame limpio.
    """
    df = pd.DataFrame(data)

    if df.empty:
        return df

    if "__type" in df.columns:
        df = df.drop(columns=["__type"])

    if "Date" in df.columns:
        df["Date"] = df["Date"].apply(parse_bing_date)
        df = df.sort_values("Date")

    return df


print("Función clean_bwt_dataframe lista")

10. Celda 6 — Probar la conexión con GetRankAndTrafficStats

El primer método que vamos a probar es GetRankAndTrafficStats. Este método devuelve estadísticas de tráfico para el sitio, como clicks e impresiones. La documentación oficial indica que los datos se actualizan diariamente e incluyen tráfico desde diferentes verticales de Bing, como Web, Chat, News, Images, Videos y Knowledge Panel desde el 24 de marzo de 2023.

try:
    test_data = bwt_get(
        method="GetRankAndTrafficStats",
        params={"siteUrl": BWT_SITE_URL}
    )

    df_test = clean_bwt_dataframe(test_data)

    print("Conexión correcta")
    display(df_test.head())
    print(f"Filas: {len(df_test)}")
    print(f"Columnas: {df_test.columns.tolist()}")

except Exception as e:
    print("Error conectando con Bing Webmaster Tools API")
    print(e)
    print("\nRevisa:")
    print("1. Que la API Key sea correcta.")
    print("2. Que el sitio esté verificado en Bing Webmaster Tools.")
    print("3. Que BWT_SITE_URL coincida exactamente con la propiedad verificada.")

Si todo funciona correctamente, deberías ver una tabla con columnas Date, Clicks e Impressions.

11. Entender los resultados de GetRankAndTrafficStats

El resultado suele incluir:

Date: fecha.
Clicks: clicks registrados por Bing.
Impressions: impresiones registradas por Bing.

Estos datos permiten crear una serie temporal para ver la evolución del rendimiento en Bing. Si suben las impresiones, el sitio está apareciendo más en Bing. Si hay muchas impresiones pero pocos clicks, puede haber oportunidades de mejorar títulos, snippets o relevancia.

12. Celda 7 — Guardar los datos en CSV

output_file = "bwt_rank_traffic_stats.csv"
df_test.to_csv(output_file, index=False, encoding="utf-8-sig")
print(f"Archivo creado: {output_file}")

Luego, en Colab, puedes descargarlo desde el panel de archivos.

13. Celda 8 — Descargar Query Stats de Bing

Otro método útil es GetQueryStats, que puede devolver datos relacionados con consultas de búsqueda en Bing, si están disponibles para la propiedad.

try:
    query_stats_data = bwt_get(
        method="GetQueryStats",
        params={"siteUrl": BWT_SITE_URL}
    )

    df_query_stats = clean_bwt_dataframe(query_stats_data)

    print("Query Stats descargado")
    display(df_query_stats.head())
    print(f"Filas: {len(df_query_stats)}")
    print(f"Columnas: {df_query_stats.columns.tolist()}")

except Exception as e:
    print("No se pudo descargar Query Stats")
    print(e)

14. Qué hacer si GetQueryStats no devuelve datos

Puede ocurrir que GetQueryStats devuelva una tabla vacía, un error o columnas diferentes a las esperadas. Esto puede depender de la propiedad verificada, el volumen de datos disponible, la configuración de la cuenta o cambios en la API.

Si esto pasa, no significa necesariamente que la API esté mal conectada. Si GetRankAndTrafficStats funciona, la conexión base está correcta.

15. Celda 9 — Guardar Query Stats en CSV

if "df_query_stats" in globals() and not df_query_stats.empty:
    output_file = "bwt_query_stats.csv"
    df_query_stats.to_csv(output_file, index=False, encoding="utf-8-sig")
    print(f"Archivo creado: {output_file}")
else:
    print("No hay datos de Query Stats para exportar.")

16. Celda 10 — Crear una gráfica de clicks e impresiones

Una vez descargados los datos de Rank & Traffic, puedes crear una gráfica rápida.

import matplotlib.pyplot as plt

if "df_test" in globals() and not df_test.empty:
    df_plot = df_test.copy()
    df_plot["Date"] = pd.to_datetime(df_plot["Date"])

    plt.figure(figsize=(12, 5))
    plt.plot(df_plot["Date"], df_plot["Clicks"], label="Clicks")
    plt.plot(df_plot["Date"], df_plot["Impressions"], label="Impressions")

    plt.title("Bing Webmaster Tools: Clicks e impresiones")
    plt.xlabel("Fecha")
    plt.ylabel("Volumen")
    plt.legend()
    plt.grid(True)
    plt.show()

else:
    print("No hay datos para graficar.")

17. Cómo conectar estos datos con Google Sheets

Si quieres enviar los datos automáticamente a Google Sheets, puedes usar gspread.

!pip install -q gspread gspread_dataframe

from google.colab import auth
auth.authenticate_user()

import gspread
from google.auth import default
from gspread_dataframe import set_with_dataframe

creds, _ = default()
gc = gspread.authorize(creds)

SPREADSHEET_ID = "PEGA_AQUI_EL_ID_DE_TU_GOOGLE_SHEET"
sh = gc.open_by_key(SPREADSHEET_ID)

print("Google Sheet conectada")
print(sh.url)

def write_df_to_sheet(spreadsheet, tab_name, df):
    df = df.copy()

    try:
        worksheet = spreadsheet.worksheet(tab_name)
        worksheet.clear()
    except Exception:
        rows = max(len(df) + 20, 100)
        cols = max(len(df.columns) + 5, 10) if not df.empty else 10
        worksheet = spreadsheet.add_worksheet(title=tab_name, rows=rows, cols=cols)

    if df.empty:
        worksheet.update("A1", [["Sin datos"]])
    else:
        set_with_dataframe(worksheet, df)

    print(f"Tab actualizada: {tab_name} | Filas: {len(df)}")

write_df_to_sheet(sh, "RAW_BWT_RankTraffic", df_test)

if "df_query_stats" in globals() and not df_query_stats.empty:
    write_df_to_sheet(sh, "RAW_BWT_QueryStats", df_query_stats)

18. Errores comunes y cómo solucionarlos

Error: InvalidApiKey. Significa que la API Key no es correcta, fue eliminada o está mal copiada. Genera una nueva API Key, copia la clave completa y vuelve a ejecutar la celda de configuración.

Error: el sitio no devuelve datos. Puede pasar si la URL usada en el script no coincide con la propiedad verificada. Revisa si en Bing Webmaster Tools la propiedad aparece exactamente como la tienes en BWT_SITE_URL.

Error: Status distinto de 200. Puede deberse a API Key incorrecta, sitio no verificado, endpoint mal escrito, problema temporal de la API o parámetros incorrectos. El script imprime la URL de request ocultando la API Key para ayudarte a revisar qué se está enviando.

La tabla sale vacía. Si la conexión funciona pero no hay datos, puede ser porque el sitio tiene poco volumen en Bing, el método consultado no tiene datos disponibles, la API devuelve datos con una estructura diferente o el periodo o tipo de dato no aplica para esa propiedad.

19. Buenas prácticas de seguridad

No pegues tu API Key en documentos públicos.
No subas notebooks con la API Key escrita directamente.
Usa getpass() para pegar la clave de forma oculta.
Si la API Key se expone, elimínala y genera una nueva.

Microsoft advierte que, si una API Key se pierde o queda comprometida, se debe eliminar y generar una nueva desde Bing Webmaster Tools.

20. Qué puedes hacer después

Una vez conectada la API, puedes usar estos datos para:

Crear reportes automáticos de tráfico en Bing.
Comparar Google Search Console vs Bing Webmaster Tools.
Analizar tendencias de clicks e impresiones.
Guardar datos históricos en Google Sheets.
Crear dashboards en Looker Studio.
Combinar estos datos con Grounding Queries de AI Performance.
Detectar si Bing/Copilot está dando visibilidad a contenidos concretos.

Conclusión

Conectar Bing Webmaster Tools API con Google Colab permite extraer datos de Bing de forma automatizada y llevarlos a tablas o dashboards.

La forma más sencilla de empezar es usando una API Key y el método GetRankAndTrafficStats, que permite validar rápidamente si la conexión funciona.

A partir de ahí, puedes ampliar el análisis con otros métodos, guardar datos en Google Sheets o cruzarlos con datos de Google Search Console. Este flujo es especialmente útil para crear análisis SEO y GEO sin depender únicamente de la interfaz visual de Bing Webmaster Tools.