Google Search Console Api Python
Guía paso a paso: como
Guía paso a paso: como conectarse con Python a la Api Google Search console
Seo api
La API de Google Search Console es una herramienta poderosa para los SEOs y aquellos que también tengan proyectos sin ser SEOs, ofreciendo acceso a una amplia gama de KPIs (Indicadores Clave de Rendimiento) críticos para el análisis y optimización del rendimiento de un sitio web en los resultados de búsqueda de Google. Con esta API, se pueden extraer detalladamente métricas como clics, impresiones, CTR (tasa de clics), y posición media de las palabras clave. Además, proporciona datos valiosos sobre las consultas de búsqueda, las páginas más visitadas, el rendimiento por tipo de dispositivo y la distribución geográfica de los usuarios.
El mundo del SEO es dinámico y requiere de herramientas efectivas para su análisis y mejora continua. En este contexto, las APIs de SEO se han convertido en aliados fundamentales para los profesionales del marketing digital. Permiten automatizar tareas, obtener datos en tiempo real y realizar ajustes precisos en las estrategias de posicionamiento web, todo ello gracias a la capacidad de integrarse con diversos softwares y plataformas.
Una de las herramientas más poderosas para monitorear el rendimiento de un sitio web en los resultados de búsqueda es la Google Search Console API. Esta API provee un acceso programático a gran parte de la información que Google Search Console ofrece, como los datos de tráfico de búsqueda, errores de rastreo y las consultas de búsqueda que llevan a los usuarios a nuestro sitio web, lo que es crucial para tomar decisiones basadas en datos.
Utilizar la Google Search Console API con Python abre un abanico de posibilidades para los desarrolladores y especialistas en SEO. Python es conocido por su simplicidad y eficiencia, lo que facilita la escritura de scripts para extraer, analizar y visualizar los datos de SEO de manera automatizada. Esto permite ahorrar tiempo y recursos, y posibilita la ejecución de análisis complejos y personalizados que pueden ir más allá de las funcionalidades estándar de la consola de búsqueda. Literalmente te vas a convertir en un experto en Google Search Console.
En definitiva al hablar de SEO API, es importante mencionar la tendencia hacia la personalización y la precisión en las estrategias de SEO. Las APIs nos permiten obtener datos específicos y realizar ajustes finos en tiempo real, lo que se traduce en una ventaja competitiva significativa. La capacidad de adaptarse rápidamente a los cambios en los algoritmos de búsqueda y a las tendencias del mercado es, sin duda, una de las claves para el éxito en el posicionamiento web actual. Si esto le sumamos Python para búsquedas en Google, tenemos un abanico de automatización enorme y con un gran potencial de nuevos análisis.
En términos de volumen de datos, la API permite hacer un número significativo de solicitudes por día. Cada una de estas solicitudes puede retornar hasta 25,000 filas de datos, lo que significa que es posible extraer una gran cantidad de información diariamente frente a las 1000 filas de datos que te deja exportar la interfaz de google search console. Al extrapolar esto al mes o al año, la cantidad de datos disponibles para análisis se vuelve verdaderamente considerable, permitiendo a los especialistas en SEO realizar un seguimiento exhaustivo y una evaluación precisa del rendimiento de un sitio web a lo largo del tiempo. Esta capacidad de extracción y análisis profundo es lo que convierte a la API de Google Search Console en una herramienta indispensable para cualquier estrategia de SEO efectiva.
+1 505 302 1649
Configuración inicial y conexión:
Acceder a la API de Google Search Console requiere una configuración inicial en Google Cloud Platform, donde se pueden elegir dos métodos de autenticación principales: OAuth2 y la Cuenta de Servicio. Una vez configurada esta parte, vamos a utilizar Python para interactuar con la API. El código necesario para ello, como se muestra a continuación, involucra establecer la conexión utilizando las credenciales previamente configuradas. Este paso es crucial para poder empezar a extraer y analizar los datos de Google Search Console de manera efectiva.
¿Existe un código de autorización de Google Search Console?
En el contexto de la API de Google Search Console, el código de autorización se refiere a las credenciales necesarias para acceder a los datos del sitio web de manera programática. Esto incluye la API Key, que es una clave de autenticación que permite a los desarrolladores integrar los datos de Search Console en sus aplicaciones o herramientas de análisis
from googleapiclient.discovery import build
from oauth2client.service_account import ServiceAccountCredentials
# Reemplaza con el camino a tu archivo de credenciales de Google
KEY_FILE_LOCATION = 'tu_archivo_de_credenciales.json'
SCOPES = ['https://www.googleapis.com/auth/webmasters.readonly']
credentials = ServiceAccountCredentials.from_json_keyfile_name(KEY_FILE_LOCATION, SCOPES)
service = build('webmasters', 'v3', credentials=credentials)
Realizar una consulta a la API
En el siguiente fragmento de código Python, estableceremos nuestra primera conexión con Google Search Console a través de su API. La ejecución de este código implica realizar una petición configurada con cuatro variables clave: site_url, start_date, end_date y row_limit.
- site_url: Corresponde a la URL del sitio que hemos configurado en Google Search Console. Si el sitio está configurado como dominio, deberemos usar el formato sc-domain:tu-sitio-web.com.
- start_date: Define la fecha de inicio para la extracción de datos.
- end_date: Establece la fecha límite hasta donde queremos recopilar los datos.
- row_limit: Especifica el número máximo de filas de datos que deseamos extraer en nuestra consulta.
Despues en la petición podemos ver dimensions
site_url = 'https://tu-sitio-web.com'
start_date = '2022-01-01'
end_date = '2022-01-31'
row_limit = '1000'
request = {
'startDate': start_date,
'endDate': end_date,
'dimensions': ['query', 'date'],
'rowLimit': row_limit
}
response = service.searchanalytics().query(siteUrl=site_url, body=request).execute()
En la API de Google Search Console, el término dimensions o también conocidas como las “Google Search Console API dimensions” se refiere a los diferentes aspectos o características de los datos que deseas recuperar en tu consulta. Estas dimensiones determinan cómo se categorizan y se desglosan los datos en los resultados que obtienes. Con esto ya vas a empezar a conocer el tráfico de búsqueda Search Console. Algunas de las dimensiones más comunes que puedes especificar en tu petición incluyen:
- query: Esta dimensión te permite obtener datos sobre las consultas de búsqueda que los usuarios han realizado y que han llevado a tu sitio web. Por ejemplo, podrás ver qué términos de búsqueda específicos están utilizando los usuarios para encontrar tu página.
- date: Al especificar esta dimensión, los datos se desglosarán por fecha, permitiéndote ver cómo cambia el rendimiento de tu sitio web a lo largo del tiempo. Es útil para identificar tendencias o efectos estacionales.
- page: Esta dimensión categoriza los datos por las páginas individuales de tu sitio web. Así, puedes ver qué páginas específicas están obteniendo más tráfico o tienen un mejor rendimiento en los resultados de búsqueda.
- country: Al usar esta dimensión, puedes ver los datos desglosados por país, lo cual es útil si tu sitio web atiende a una audiencia internacional y deseas comprender cómo se comportan los usuarios en diferentes regiones.
- device: Esta dimensión divide los datos según el tipo de dispositivo utilizado por el usuario, como móviles, tablets o versión de escritorio. Te permite adaptar mejor tu sitio web a las diferentes experiencias de usuario en cada tipo de dispositivo.
Al combinar estas dimensiones en tu petición a la API, puedes obtener un conjunto de datos muy detallado y específico que te ayudará a comprender mejor el rendimiento de tu sitio web en los resultados de búsqueda de Google y a tomar decisiones informadas para mejorar tu estrategia SEO.
Convertir los datos en un DataFrame de Pandas:
La manipulación y análisis de datos son habilidades esenciales en el campo del SEO, especialmente cuando se trabaja con grandes volúmenes de datos como los proporcionados por la API de Google Search Console. Aquí es donde entra en juego Pandas, una poderosa biblioteca de Python que ofrece estructuras de datos y herramientas de análisis diseñadas para facilitar la manipulación y el análisis de datos. Tener un conocimiento sólido de Pandas es esencial para transformar los datos crudos en insights valiosos que pueden informar y guiar las estrategias de SEO.
El código proporcionado es un ejemplo práctico de cómo Pandas puede ser utilizado para este propósito:
Importar Pandas
import pandas as pd
Crear un DataFrame Vacío
Creamos un DataFrame vacío con columnas específicas. Un DataFrame es una estructura de datos bidimensional, similar a una tabla de Excel, que puede almacenar datos de diferentes tipos (como texto, números, fechas) y es ideal para manipular grandes conjuntos de datos.
df = pd.DataFrame(columns=['query', 'date', 'clicks', 'impressions', 'ctr', 'position'])
Llenar el DataFrame con Datos
En el siguiente codigo, el bucle (for), iteramos sobre cada fila de la respuesta obtenida de la API de Google Search Console. Cada fila contiene información sobre una consulta de búsqueda, incluyendo la consulta (‘query’), la fecha (‘date’), los clics (‘clicks’), las impresiones (‘impressions’), la tasa de clics (‘ctr’) y la posición en los resultados de búsqueda (‘position’). Estos datos se añaden al DataFrame, creando así un conjunto de datos estructurado y fácil de analizar.
Una vez que los datos están en un DataFrame, puedes realizar una variedad de análisis y operaciones de manipulación de datos, como agrupar por ciertas columnas, filtrar datos basados en condiciones específicas, calcular estadísticas resumidas, y mucho más. Por ejemplo, podrías querer analizar el CTR promedio de diferentes consultas, o ver cómo las impresiones de tu sitio web cambian a lo largo del tiempo. Pandas te proporciona las herramientas para realizar estos análisis de manera eficiente, convirtiéndolo en un componente esencial en el arsenal de cualquier profesional de SEO que trabaja con datos.
for row in response['rows']:
df = df.append({
'query': row['keys'][0],
'date': row['keys'][1],
'clicks': row['clicks'],
'impressions': row['impressions'],
'ctr': row['ctr'],
'position': row['position']
}, ignore_index=True)
Importancia de los graficos
En el mundo de la analítica y el SEO, la representación visual de los datos es fundamental. Aunque las tablas o hojas de Excel proporcionan una visión detallada y son herramientas útiles para la manipulación de datos, a menudo no son suficientes para captar rápidamente la esencia de la información. Los gráficos, en cambio, permiten una comprensión instantánea y profunda de los insights clave, facilitando la identificación de tendencias, patrones y anomalías a simple vista. Si bien Pandas y sus DataFrames son excelentes para organizar y preparar datos, la visualización efectiva de estos requiere de herramientas adicionales. Aquí es donde entran en juego librerías de Python especializadas en visualización de datos, como Matplotlib, Seaborn o Plotly. Estas librerías transforman los conjuntos de datos en representaciones gráficas intuitivas y detalladas, permitiendo a los analistas y profesionales de SEO comunicar resultados complejos de manera clara y convincente. Con estas herramientas, los datos no solo se vuelven más accesibles, sino que también facilitan la toma de decisiones basadas en datos y el desarrollo de estrategias SEO más efectivas.
Gráfico de Líneas para Clicks e Impresiones a lo Largo del Tiempo
Te explico, lo que hace el siguiente codigo:
El código presentado utiliza la librería Matplotlib, es una herramienta para la visualización de datos en Python, para crear un gráfico que ilustre estas variaciones. Inicialmente, transformamos la columna ‘date’ en un formato de fecha y hora reconocible, lo que facilita su manejo en análisis temporales. Luego, agrupamos los datos por fecha y sumamos los valores para cada día. El resultado se visualiza en un gráfico de líneas, donde trazamos tanto los clics como las impresiones a lo largo del tiempo. Este enfoque permite observar tendencias, picos y caídas en el tráfico web, proporcionando una visión clara de la eficacia de las estrategias SEO implementadas. Al observar cómo estos dos indicadores clave fluctúan y se correlacionan, los profesionales de SEO pueden hacer ajustes informados para optimizar la presencia en línea de su sitio web.
import matplotlib.pyplot as plt
df['date'] = pd.to_datetime(df['date'])
df_grouped = df.groupby('date').sum()
plt.figure(figsize=(12, 6))
plt.plot(df_grouped.index, df_grouped['clicks'], label='Clicks')
plt.plot(df_grouped.index, df_grouped['impressions'], label='Impresiones')
plt.xlabel('Fecha')
plt.ylabel('Cantidad')
plt.title('Clicks e Impresiones a lo Largo del Tiempo')
plt.legend()
plt.show()
Gráfico de Barras para Comparar CTR por Dispositivo
En siguiente código. Primero, agrupa los datos por el tipo de dispositivo y calcula el CTR promedio para cada uno. Luego, emplea Matplotlib, para crear un gráfico de barras que muestra de manera clara y concisa estas medias de CTR.
df_device = df.groupby('device')['ctr'].mean()
df_device.plot(kind='bar', figsize=(10, 6))
plt.xlabel('Dispositivo')
plt.ylabel('CTR Promedio')
plt.title('CTR por Dispositivo')
plt.show()
Heatmap o mapas de calor para Posiciones de Palabras Clave
Este código utiliza Seaborn para crear un ‘heatmap’ que visualiza el rendimiento de palabras clave en los resultados de búsqueda. Al agrupar los clics por consulta y posición, el mapa de calor destaca las áreas donde las palabras clave son más efectivas, permitiendo a los profesionales de SEO identificar rápidamente patrones y optimizar estrategias.
import seaborn as sns
# Asumiendo que 'position' está en un rango específico, por ejemplo, 1-10
heatmap_data = pd.pivot_table(df, values='clicks', index=['query'], columns='position', aggfunc='sum')
plt.figure(figsize=(12, 8))
sns.heatmap(heatmap_data, cmap='YlGnBu')
plt.title('Heatmap de Posiciones de Palabras Clave')
plt.show()
Espero que te haya servido de ayuda y si por algún casual quieres saber mas no dudes en ingresar en nuestra comunidad gratuita donde vas a ver a más contenido sobre cómo usar una api en python y mucho más. También, si quieres ser experto en Data Seo con Python junto con todos los beneficios de Google Search API con Python, tenemos nuestro programa y dentro puedes agendar una call conmígo y ver que soluciones podemos darte para que tu tiempo sea tuyo.
Posición media Google Search Console: Métricas, Interpretación y Acciones
La posición media es una de las métricas más valiosas pero malinterpretadas en Google Search Console. A diferencia de herramientas de terceros, esta métrica:
- Representa un promedio ponderado por volumen de búsquedas
- Considera todas las impresiones, no solo muestras
- Varía significativamente por dispositivo (móvil vs. desktop)
Análisis avanzado con Python:
# Calcular posición media por consulta con umbral de relevancia
df_posicion = df[df['impressions'] > 50].groupby('query')['position'].agg(
['mean', 'count', 'std']
).sort_values('mean')
# Identificar oportunidades SEO
oportunidades = [df_posicion[
(df_posicion['mean'].between(5, 15)) & (df_posicion['count'] > 100) & (df_posicion['std'] < 3)]
Cómo exportar datos de Google Search Console: Técnicas Profesionales y Automatización
Exportar datos manualmente limita a 1,000 filas y es propenso a errores. La solución profesional implica:
Flujo de exportación automatizado:
- Configuración inicial:
from googleapiclient.discovery import build
from google.oauth2 import service_account
creds = service_account.Credentials.from_service_account_file(
'service-account.json',
scopes=['https://www.googleapis.com/auth/webmasters.readonly']
)
service = build('webmasters', 'v3', credentials=creds)
- Función para extracción completa:
def exportar_datos_completos(site_url, start_date, end_date, dimensions):
all_rows = []
request = {
'startDate': start_date,
'endDate': end_date,
'dimensions': dimensions,
'rowLimit': 25000,
'startRow': 0
}
while True:
response = service.searchanalytics().query(
siteUrl=site_url,
body=request
).execute()
if 'rows' in response:
all_rows.extend(response['rows'])
request['startRow'] += len(response['rows'])
else:
break
if len(all_rows) >= 100000: # Límite seguro
break
return pd.DataFrame(all_rows)
Mejores prácticas:
- Programar extracciones diarias con Cloud Scheduler
- Almacenar históricos en BigQuery
- Implementar checks de calidad de datos
Google Webmaster API vs. Search Console API: Evolución Técnica y Beneficios
La transición de Webmaster Tools API a Search Console API representa un salto cuántico en capacidades:
Tabla comparativa detallada:
| Característica | Webmaster API | Search Console API | Beneficio |
|---|---|---|---|
| Límite datos | 1,000 filas | 25,000 filas | 25x más datos por consulta |
| Frecuencia actualización | 72h delay | 16-48h delay | Datos más frescos |
| Dimensiones | 3 máx. | 7 combinables | Análisis multidimensional |
| Filtros | Básicos | Avanzados | Segmentación precisa |
| Autenticación | OAuth complejo | Service Accounts + OAuth | Más opciones |
Caso de uso avanzado:
# Consulta multidimensional con filtros
request = {
'startDate': '2023-01-01',
'endDate': '2023-12-31',
'dimensions': ['query','page','device','country'],
'dimensionFilterGroups': [{
'filters': [{
'dimension': 'country',
'operator': 'equals',
'expression': 'COL'
}]
}],
'rowLimit': 25000
}
Google Search Console Query: Análisis Avanzado de Search Queries
Transforma datos crudos en insights accionables con estas técnicas:
1. Clasificación semántica:
import re
def clasificar_consultas(query):
if re.search(r'b(cómo|como|guía|tutorial)b', query, re.IGNORECASE):
return 'Informacional'
elif re.search(r'b(mejor|top|comparativa|vs)b', query):
return 'Comparación'
elif re.search(r'b(comprar|precio|barato|oferta)b', query):
return 'Transaccional'
else:
return 'Navegacional'
df['tipo_consulta'] = df['query'].apply(clasificar_consultas)
2. Análisis de tendencias temporales:
from statsmodels.tsa.seasonal import seasonal_decompose
# Preparar datos temporales
ts_data = df.groupby('date')['clicks'].sum().resample('D').sum()
# Descomposición estacional
result = seasonal_decompose(ts_data.fillna(0), model='additive', period=30)
result.plot();
3. Detección de oportunidades long-tail:
# Filtro avanzado para long-tail
long_tail = df[
(df['query'].str.split().str.len() >= 4) &
(df['position'] <= 20) &
(df['ctr'] < 0.03) &
(df['impressions'] > 50)
].sort_values('impressions', ascending=False)
Google Search Console CTR: Estrategias Basadas en Datos para Mejorar el Click-Through Rate
El CTR es el termómetro de la efectividad de tus snippets. Estrategias comprobadas:
1. Optimización basada en posición:
# Calcular CTR esperado por posición
ctr_esperado = df.groupby('position')['ctr'].agg(['mean', 'median', 'std'])
# Identificar underperformers
df['ctr_gap'] = df['ctr'] - df['position'].map(ctr_esperado['mean'])
oportunidades_ctr = df[df['ctr_gap'] < -0.5].sort_values('impressions', ascending=False)
2. Test A/B de meta tags:
# Simulación de tests (datos reales requerirían integración con CMS)
tests_meta = {
'original': ['Mejor Producto 2023', 'Descripción genérica'],
'variante1': ['Producto X - #1 en Ventas 2023', '60% de descuento hoy'],
'variante2': ['¿Por qué Producto X tiene 5 estrellas?', 'Ver testimonios reales']
}
for version, (title, desc) in tests_meta.items():
df.loc[df['page'] == 'producto-x', f'title_{version}'] = title
df.loc[df['page'] == 'producto-x', f'desc_{version}'] = desc
Cómo saber en qué posición está mi web en Google: Técnicas Avanzadas de Tracking
Más allá del promedio simple:
1. Tracking por tipo de contenido:
# Clasificación automática de URLs
df['tipo_contenido'] = 'otros'
df.loc[df['page'].str.contains('/blog/|/articulos/'), 'tipo_contenido'] = 'blog'
df.loc[df['page'].str.contains('/producto/|/categoria/'), 'tipo_contenido'] = 'producto'
df.loc[df['page'].str.contains('/landing/|/promo/'), 'tipo_contenido'] = 'landing'
# Análisis comparativo
posicion_por_tipo = df.groupby(['tipo_contenido','device'])['position'].agg(
['mean','median','count']
)
2. Monitorización competitiva:
# Configuración de competidores
competidores = {
'competidor1': 'competidor1.com',
'competidor2': 'competidor2.com'
}
for nombre, dominio in competidores.items():
df[f'pos_{nombre}'] = df[df['page'].str.contains(dominio)].groupby('query')['position'].transform('mean')
# Gap competitivo
df['gap_pos_vs_competidor1'] = df['position'] - df['pos_competidor1']
3. Sistema de alertas automatizado:
from datetime import datetime, timedelta
# Detección de caídas significativas
df['change_pos_7d'] = df.groupby('query')['position'].pct_change(periods=7)
alertas = df[
(df['change_pos_7d'] > 0.3) &
(df['date'] == datetime.today().strftime('%Y-%m-%d')) &
(df['impressions'] > 100)
]
# Exportar alertas
alertas[['query','page','position','change_pos_7d']].to_csv('alertas_posicion.csv', index=False)