Automatización análisis con Page Speed Insights y Python
Como SEO, seguro te has
Como SEO, seguro te has encontrado con la necesidad de analizar el rendimiento de múltiples URLs de manera eficiente. La automatización, usando herramientas como Python y APIs como PageSpeed Insights, puede transformar la forma en que abordas esta tarea, ahorrándote tiempo y permitiéndote enfocarte en la estrategia. ¡Vamos a sumergirnos en cómo hacerlo!
Introducción a la automatización de análisis de rendimiento de URLs
¿Te ha pasado que la interfaz de PageSpeed Insights se vuelve lenta al analizar varias URLs? A mí también. Por eso, construir una automatización mediante la API de PageSpeed Insights se convierte en una solución ideal. No solo agilizamos el proceso, sino que también abrimos la puerta a personalizar y adaptar el análisis a nuestras necesidades específicas. La automatización no es más que tocar un botón y ver cómo se ejecutan un montón de instrucciones, liberándonos de tareas repetitivas y permitiéndonos extrapolar soluciones a otros análisis.
Framework para pensar el problema
Antes de lanzarnos al código, es crucial estructurar nuestro enfoque. Personalmente, me gusta usar herramientas como ScrinTal para diagramar flujos de trabajo. Un amigo de la comunidad privada de Data SEO me la recomendó y, la verdad, ¡es súper útil! Ahora, volviendo al problema: tenemos un conjunto de URLs y queremos analizar su rendimiento con PagePinsight.
Necesitamos un input que nos permita ingresar la cantidad de URLs a analizar: 1, 2, 10, 50… las que necesitemos. Idealmente, podríamos conectarnos a la Custom Search API de Google para extraer el top 10 de URLs que posicionan para una query específica. De hecho, en otro video te mostraré cómo hacerlo. Luego, analizaríamos ese conjunto de URLs con PageSpeed Insights para obtener sus métricas.
Uso de PageSpeed Insights API para analizar rendimiento de URLs
Para esta parte, necesitamos las credenciales de la PageSpeed Insights API y entender su documentación para extraer la información que nos interesa. Si no sabes cómo generar las credenciales, tengo un video en mi canal donde te muestro cómo hacerlo. ¡Es muy sencillo! Además, si usas Screaming Frog, ¡es la misma API!
PageSpeed Insights API ofrece una enorme cantidad de variables que podemos extraer. En este caso, nos concentraremos en 5 métricas clave, pero una vez que entiendas la lógica, podrás agregar tantas columnas como quieras a tu proyecto. Luego, construiremos un dataframe (una tabla) con las URLs y sus métricas, y finalmente, ¡un gráfico para visualizar y comparar los resultados!
Integración de Custom Search API para extraer URLs
Aunque en este artículo nos enfocamos en ingresar las URLs manualmente, la integración con la Custom Search API de Google es un paso crucial para automatizar aún más el proceso. Esta API nos permite, a través de una consulta (query), extraer las URLs que están posicionando en las SERPs. Imagina el poder de analizar automáticamente el rendimiento de las URLs de tus competidores para una palabra clave específica… es oro puro para tu estrategia SEO
Cómo extraer URLs con Custom Search API
La Custom Search API requiere credenciales, al igual que PageSpeed Insights. Una vez que las tengas, puedes realizar consultas y recibir un listado de URLs como respuesta. Este listado será el input para nuestro análisis con PagePinsight. En el próximo video, te mostraré cómo combinar ambas APIs para crear un flujo de trabajo completamente automatizado.
Automatización del proceso con Python
¡Aquí es donde la magia sucede! Usaremos Python para automatizar todo el proceso. Para ello, utilizaremos Google Colab, un entorno de desarrollo en la nube que nos permite escribir y ejecutar código Python sin necesidad de instalar nada en nuestra computadora. Si no estás familiarizado con Google Colab, te recomiendo que veas alguno de mis videos donde explico cómo funciona.
El problema que estamos resolviendo es la lentitud de la interfaz de PageSpeed Insights al analizar URLs a escala. Pero, ¿por qué es un problema? Porque nos lleva tiempo. Y ese tiempo, sumado a otras tareas lentas, nos cansa y nos impide enfocarnos en lo que realmente importa. Aprender a programar en Python es como subirte a un Ferrari: aumenta tu velocidad de ejecución y te acerca más rápido a tus objetivos.
¿Cómo automatizar el proceso con Python?
Vamos a crear una función en Python que se conecte a la API de PageSpeed Insights, extraiga las métricas que nos interesan y las guarde en un dataframe. Esta función recibirá como input las URLs que queremos analizar y nuestras credenciales de la API. Para ello, importaremos las siguientes librerías:
requests: Para conectarnos a la API de PageSpeed Insights.NumPy: Para generar variables.pandas: Para trabajar con DataFrames.matplotlib: Para crear gráficos.
import requests
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
def obtener_datos_pagespeed(lista_urls, api_key, estrategia='mobile'):
"""
Se conecta a la API de Google PageSpeed Insights para una lista de URLs,
extrae métricas clave de rendimiento y las devuelve en un DataFrame de Pandas.
Args:
lista_urls (list): Una lista de strings, donde cada string es una URL a analizar.
api_key (str): Tu clave API de Google para usar PageSpeed Insights.
estrategia (str, optional): La estrategia de análisis ('mobile' o 'desktop').
Por defecto es 'mobile'.
Returns:
pandas.DataFrame: Un DataFrame con las métricas de rendimiento para cada URL,
o un DataFrame vacío si ocurren errores o no hay datos.
"""
datos_finales = []
endpoint_api = "https://www.googleapis.com/pagespeedonline/v5/runPagespeed"
print(f"Iniciando análisis con estrategia: {estrategia}")
for url in lista_urls:
print(f"Procesando URL: {url}...")
params = {
'url': url,
'key': api_key,
'strategy': estrategia,
'category': 'PERFORMANCE'
}
try:
response = requests.get(endpoint_api, params=params, timeout=120)
response.raise_for_status()
resultado_json = response.json()
lighthouse_metrics = resultado_json.get('lighthouseResult', {})
categorias = lighthouse_metrics.get('categories', {})
audits = lighthouse_metrics.get('audits', {})
score_rendimiento = categorias.get('performance', {}).get('score')
score_rendimiento = int(score_rendimiento * 100) if score_rendimiento is not None else None
fcp = audits.get('first-contentful-paint', {}).get('numericValue')
lcp = audits.get('largest-contentful-paint', {}).get('numericValue')
cls = audits.get('cumulative-layout-shift', {}).get('numericValue')
tti = audits.get('interactive', {}).get('numericValue')
tbt = audits.get('total-blocking-time', {}).get('numericValue')
speed_index = audits.get('speed-index', {}).get('numericValue')
datos_url = {
'URL': url,
'Estrategia': estrategia,
'Performance Score': score_rendimiento,
'First Contentful Paint (ms)': fcp,
'Largest Contentful Paint (ms)': lcp,
'Cumulative Layout Shift': cls,
'Time to Interactive (ms)': tti,
'Total Blocking Time (ms)': tbt,
'Speed Index (ms)': speed_index
}
datos_finales.append(datos_url)
print(f" -> ¡Éxito!")
except requests.exceptions.RequestException as e:
print(f" -> Error al solicitar la API para {url}: {e}")
except Exception as e:
print(f" -> Error inesperado procesando {url}: {e}")
print("Análisis completado.")
df_resultados = pd.DataFrame(datos_finales)
return df_resultados
MI_API_KEY = "TU_API_KEY_AQUI"
urls_para_analizar = [
"https://www.google.com",
"https://www.wikipedia.org",
"https://www.python.org",
"https://una_url_que_falla_proposito.xyz"
]
if MI_API_KEY == "TU_API_KEY_AQUI":
print("¡ADVERTENCIA! Debes reemplazar 'TU_API_KEY_AQUI' con tu clave API real.")
else:
df_movil = obtener_datos_pagespeed(urls_para_analizar, MI_API_KEY, estrategia='mobile')
print("n--- Resultados Móvil ---")
print(df_movil.to_string())
df_desktop = obtener_datos_pagespeed(urls_para_analizar, MI_API_KEY, estrategia='desktop')
print("n--- Resultados Escritorio ---")
print(df_desktop.to_string())
df_completo = pd.concat([df_movil, df_desktop], ignore_index=True)
print("n--- Resultados Combinados ---")
print(df_completo.to_string())
df_movil.to_csv('resultados_pagespeed_movil.csv', index=False)
import matplotlib.pyplot as plt
if not df_movil.empty and 'Performance Score' in df_movil.columns:
df_movil.plot(kind='bar', x='URL', y='Performance Score', title='Puntuación Performance (Móvil)')
plt.xticks(rotation=45, ha='right')
plt.tight_layout()
plt.show()Visualización de resultados con gráficos
Una vez que hayamos extraído las métricas de todas las URLs, las guardaremos en un dataframe de pandas. Luego, usaremos matplotlib para crear gráficos que nos permitan comparar el rendimiento de las diferentes URLs.
¿Cómo visualizar los resultados con gráficos?
Podemos crear diferentes tipos de gráficos, como gráficos de barras, gráficos de líneas o gráficos de dispersión, dependiendo de las métricas que queramos comparar. Lo importante es que los gráficos sean claros y fáciles de entender, para que podamos identificar rápidamente las áreas de mejora.
Al final, el script generará un gráfico automático donde se compararán las métricas de las distintas URLs. Esto nos permitirá identificar rápidamente las oportunidades de mejora y cómo se comparan nuestros competidores para la query que estamos analizando.
¿Cómo integrar diferentes APIs y soluciones?
La belleza de la automatización con Python es que podemos integrar diferentes APIs y soluciones para crear flujos de trabajo personalizados. Por ejemplo, podemos conectar la API de PagePinsight con una base de datos para guardar un histórico de las métricas de nuestras URLs. También podemos integrar la API de Google Analytics para obtener datos de tráfico y comportamiento de los usuarios.
¿Cómo automatizar el proceso para diferentes proyectos?
Una vez que hayas creado un script de automatización, puedes reutilizarlo para diferentes proyectos. Lo único que tienes que hacer es modificar las URLs que quieres analizar y las credenciales de la API. También puedes personalizar el script para extraer diferentes métricas o crear diferentes tipos de gráficos.