Estratégia para reescrever artigos técnicos antigos usando o Google Search Console

Sat, 12 Sep 2026 12:00:00 +0900

1. Introdução: A importância da reescrita e uma abordagem baseada em dados em blogs técnicos

Ao gerenciar um blog técnico ou mídia própria voltada para desenvolvedores, a “reescrita de artigos antigos” é tão ou mais importante do que a escrita contínua de novos artigos. Especialmente em tópicos técnicos e de TI, as informações se tornam obsoletas rapidamente, e não é incomum que trechos de código ou especificações de API escritos há alguns anos sejam agora descontinuados (Deprecated). No entanto, atualizar cegamente artigos antigos não maximizará o tráfego (visitas) dos motores de busca.

Neste artigo, explicarei uma estratégia avançada para identificar quais artigos técnicos devem ser reescritos e melhorar drasticamente as classificações de pesquisa e taxas de cliques (CTR). Para isso, usaremos dados do Google Search Console (doravante GSC) e do Google Analytics 4 (GA4), adotando uma abordagem matemática e baseada em dados.

Especificamente, explicarei de forma abrangente desde como usar Python e BigQuery para integrar os dados do GSC e GA4 e encontrar “artigos de perda de oportunidade” com uma CTR baixa em relação ao número de impressões, até como identificar palavras-chave ausentes nos cabeçalhos H2 e H3 usando a análise TF-IDF de Processamento de Linguagem Natural (PNL) para preencher eficientemente as lacunas de conteúdo.

2. Análise da lacuna entre CTR esperada e CTR real (Introdução ao modelo matemático)

Um dos indicadores mais básicos em SEO é a “taxa de cliques (CTR) em relação à classificação de pesquisa”. Geralmente, a CTR para a primeira posição é de cerca de 25-30%, a segunda posição é de cerca de 15%, e diminui acentuadamente a partir daí. Essa relação entre classificação e CTR pode ser modelada como uma distribuição seguindo a Lei de Potência (Power Law).

Sabe-se que a taxa de cliques esperada $CTR(r)$ para a classificação $r$ pode ser aproximada pela seguinte fórmula:

$$ CTR(r) = a \cdot r^{-b} $$

Aqui, $a$ representa a CTR esperada para a primeira posição (por exemplo, $0.30$ para 30%) e $b$ é o parâmetro de decaimento (geralmente entre $1.0$ e $1.5$).

A abordagem mais eficaz para selecionar artigos para reescrever é encontrar artigos (palavras-chave) onde a “CTR real” está significativamente abaixo dessa “CTR esperada”. Por exemplo, se a classificação da pesquisa for a 3ª posição (CTR esperada de cerca de 10%), mas a CTR real for de apenas 2%, é muito provável que haja uma incompatibilidade entre a intenção de pesquisa e o título ou descrição, ou que os cliques estejam sendo perdidos por fatores da concorrência, como rich snippets.

O gráfico a seguir ilustra a divergência entre a CTR esperada e a CTR real em um blog técnico.

xychart-beta
title CTR Esperada vs CTR Real por Posição
x-axis ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
y-axis "CTR (%)" 0 --> 35
line [30.5, 15.2, 10.1, 7.5, 5.2, 4.1, 3.2, 2.5, 2.0, 1.5]
bar [32.1, 14.0, 8.5, 4.0, 5.0, 2.1, 1.5, 1.0, 1.2, 0.5]

(※ A linha representa a CTR esperada e o gráfico de barras mostra a CTR real. Pode-se observar que os valores estão notavelmente abaixo nas posições 4 e 8.)

3. Extração automática de dados de desempenho de pesquisa usando a API do GSC (Python)

Embora seja possível baixar CSVs da interface web do GSC para análise, a melhor abordagem para grandes blogs ou para realizar análises contínuas é construir um sistema que extraia automaticamente os dados usando Python e a API do GSC.

Abaixo está um snippet de código em Python usando google-api-python-client para obter dados de desempenho por página e por consulta (cliques, impressões, CTR, posição média) num período específico.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


import pandas as pd
from google.oauth2 import service_account
from googleapiclient.discovery import build

def get_gsc_data(key_path, site_url, start_date, end_date):
 # Carregamento de credenciais e construção do cliente de API
 credentials = service_account.Credentials.from_service_account_file(
 key_path, scopes=['https://www.googleapis.com/auth/webmasters.readonly']
 )
 service = build('searchconsole', 'v1', credentials=credentials)

 # Configuração do payload da requisição de API (especificando página e consulta como dimensões)
 request = {
 'startDate': start_date,
 'endDate': end_date,
 'dimensions': ['page', 'query'],
 'rowLimit': 25000
 }

 # Execução da API
 response = service.searchanalytics().query(
 siteUrl=site_url, body=request
 ).execute()

 # Extração de dados da resposta e conversão para Pandas DataFrame
 rows = response.get('rows', [])
 data = []
 for row in rows:
 keys = row['keys']
 data.append({
 'page': keys[0],
 'query': keys[1],
 'clicks': row['clicks'],
 'impressions': row['impressions'],
 'ctr': row['ctr'],
 'position': row['position']
 })

 return pd.DataFrame(data)

# Exemplo de execução
# df_gsc = get_gsc_data('credentials.json', 'https://kenji.blog/', '2026-08-01', '2026-08-31')
# print(df_gsc.head())

Com este script, os dados detalhados vinculando URLs de páginas e consultas de pesquisa podem ser obtidos como um DataFrame. Isso torna possível entender de forma abrangente para quais palavras-chave artigos específicos estão aparecendo.

4. Filtrando palavras-chave técnicas com Expressões Regulares (Regex)

Uma funcionalidade muito poderosa na análise de blogs técnicos é o filtro de expressões regulares (Regex) do GSC. Por exemplo, se você escreve artigos variando de frontend a backend e infraestrutura, pode querer extrair apenas “artigos de tutoriais ou de erros relacionados a Python e Pandas” para priorizar a reescrita.

Usando filtros de expressões regulares personalizadas no GSC, você pode restringir consultas sob condições complexas.

Exemplos de filtragem de palavras-chave técnicas:

Investigação de erros relacionados ao Python: ^(python|pandas|numpy|matplotlib).* (error|exception|bug|erro|não funciona)
Construção de infraestrutura AWS: (aws|amazon web services|ec2|s3|lambda).* (construção|configuração|tutorial|tutorial|how to)
Atualização de versão de biblioteca específica: (react|vue|angular) (v17|v18|v3) (migration|migração|transição)

Para incorporar isso numa requisição da API do GSC, você utiliza o dimensionFilterGroups para adicionar a condição da expressão regular. Fazendo uso intensivo dessa filtragem, você consegue extrair com precisão palavras-chave altamente valiosas orientadas para a solução de problemas, que os desenvolvedores estão “buscando justamente agora por estarem com dificuldades”.

5. Integração de dados GA4 e GSC via BigQuery/Pandas

Os dados do GSC informam apenas a “classificação de pesquisa e taxa de cliques”. Para descobrir “quanto tempo os usuários que chegaram àquele artigo realmente permaneceram e se chegaram à conversão (ex: navegação para um repositório GitHub ou assinatura de newsletter)”, é necessário integrar (JOIN) com os dados do Google Analytics 4 (GA4).

Se você está armazenando dados de exportação do GA4 e dados de exportação em massa do GSC no BigQuery, pode combiná-los usando uma consulta SQL como a seguinte. Isso permite extrair “artigos com muitas impressões e uma classificação razoável, mas que têm alta taxa de rejeição e curto tempo de engajamento”.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


WITH gsc_data AS (
 SELECT
 url AS page_path,
 SUM(impressions) AS total_impressions,
 SUM(clicks) AS total_clicks,
 AVG(sum_top_position) AS avg_position
 FROM
 `project.searchconsole.searchdata_url_impression`
 WHERE
 data_date BETWEEN '2026-08-01' AND '2026-08-31'
 GROUP BY
 url
),
ga4_data AS (
 SELECT
 REGEXP_REPLACE(
 (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'page_location'),
 r'^https?://[^/]+', ''
 ) AS page_path,
 COUNT(DISTINCT user_pseudo_id) AS users,
 AVG((SELECT value.int_value FROM UNNEST(event_params) WHERE key = 'engagement_time_msec')) / 1000 AS avg_engagement_sec
 FROM
 `project.analytics_123456789.events_*`
 WHERE
 event_name = 'page_view'
 GROUP BY
 page_path
)

SELECT
 g.page_path,
 g.total_impressions,
 g.total_clicks,
 SAFE_DIVIDE(g.total_clicks, g.total_impressions) AS ctr,
 g.avg_position,
 a.users,
 a.avg_engagement_sec
FROM
 gsc_data g
JOIN
 ga4_data a ON g.page_path = a.page_path
WHERE
 g.total_impressions > 1000
 AND g.avg_position BETWEEN 3 AND 15
ORDER BY
 g.total_impressions DESC

Com base nestes resultados, os alvos de reescrita são classificados através da seguinte matriz:

Alta Impressão, Baixo CTR, Alto Engajamento: Artigos em que os leitores ficam satisfeitos desde que cliquem nos resultados de pesquisa. A modificação do título e da meta descrição deve ser feita com prioridade máxima.
Alto CTR, Baixo Engajamento: Artigos em que clicam, mas cujo conteúdo decepciona, levando à saída do usuário. É necessária uma reescrita significativa do texto, como melhorar a introdução, atualizar para o código mais recente ou melhorar a abrangência das informações (adicionar H2/H3).

6. Análise de lacuna de conteúdo usando PNL e TF-IDF

Uma vez identificados os artigos a serem reescritos, o passo seguinte é analisar “quais subtítulos exatos (H2/H3) e palavras-chave devem ser adicionados”. Em vez de confiar na intuição aqui também, fazemos uso do TF-IDF (Frequência do Termo - Frequência Inversa do Documento) em Processamento de Linguagem Natural (PNL).

O TF-IDF é uma estatística para avaliar a importância de uma certa palavra dentro desse documento.

$$ TF\text{-}IDF(t, d) = tf(t, d) \times \log\left(\frac{N}{df(t)}\right) $$

Onde,

$tf(t, d)$ é a frequência de ocorrência da palavra $t$ no documento $d$
$N$ é o número total de documentos
$df(t)$ é o número de documentos em que a palavra $t$ aparece

Abordagem:

Obtenha os dados de texto dos top 10 artigos (sites concorrentes) para a palavra-chave alvo através de raspagem (scraping), etc.
Prepare os dados de texto para o artigo alvo em seu próprio site.
Usando o TfidfVectorizer da biblioteca scikit-learn em Python, extraia palavras-chave (palavras-recurso) que aparecem de forma consistente com altas pontuações no grupo de artigos dos principais concorrentes, mas que não existem (ou têm pontuação notavelmente baixa) no artigo de seu próprio site.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


from sklearn.feature_extraction.text import TfidfVectorizer
import pandas as pd
import numpy as np

# documents = [Texto do próprio site, Texto do concorrente 1, Texto do concorrente 2, ...]
# Aqui assume-se uma lista de textos já separados por análise morfológica (MeCab, etc.) em japonês

def extract_missing_keywords(documents):
 vectorizer = TfidfVectorizer(max_df=0.9, min_df=2)
 tfidf_matrix = vectorizer.fit_transform(documents)

 feature_names = vectorizer.get_feature_names_out()

 # Calcula a pontuação média TF-IDF dos artigos concorrentes (índice 1 em diante)
 competitor_mean_tfidf = np.mean(tfidf_matrix[1:].toarray(), axis=0)

 # Obtém a pontuação TF-IDF do artigo do próprio site (índice 0)
 my_article_tfidf = tfidf_matrix[0].toarray()[0]

 # Calcula a lacuna de palavras que são importantes nos concorrentes, mas ausentes (ou poucas) no próprio site
 gap_scores = competitor_mean_tfidf - my_article_tfidf

 # Extrai as principais palavras onde a lacuna é grande
 df_gap = pd.DataFrame({'keyword': feature_names, 'gap_score': gap_scores})
 df_gap = df_gap.sort_values(by='gap_score', ascending=False)

 return df_gap.head(20)

# Exemplo: missing_keywords = extract_missing_keywords(processed_docs)
# print(missing_keywords)

Através dessa análise, você pode descobrir quantitativamente lacunas de tópicos (lacunas de conteúdo), tais como “na verdade, os principais artigos mencionam sobre ‘como implantar em contêineres Docker’ e ‘construir um pipeline CI/CD’, mas não toco nisso no meu artigo”.

O conjunto de palavras-chave importantes descobertas não deve ser simplesmente espalhado no texto, mas sim adicionado como seções significativas como cabeçalhos H2 e H3 (tags de Heading). Escrever explicações técnicas detalhadas e trechos de código para esses cabeçalhos pode melhorar drasticamente a avaliação do Google.

7. Pipeline de dados e ciclo de melhoria contínua

O processo explicado até agora não acaba após uma única execução; transformá-lo num pipeline e executá-lo de forma contínua é a chave do sucesso em SEO. A arquitetura geral e o fluxo operacional são exibidos num fluxograma Mermaid abaixo.

flowchart TD
A["Dados da API do GSC (Impressões, Cliques, Posições)"] --> C["BigQuery / Data Warehouse"]
B["Dados de Exportação do GA4 (Visualizações de Página, Tempo de Engajamento)"] --> C
C --> D["Junção e Análise de Dados com Python / Pandas"]
D --> E["Identificar Artigos com Alta Impressão / Baixo CTR"]
E --> F["Scraping de Concorrentes com PNL e Extração de Palavras-chave TF-IDF"]
F --> G["Otimizar Tags H2/H3 e Reescrever Conteúdo"]
G --> H["Publicar Artigo Atualizado"]
H --> I["Monitorar Alterações de CTR (Esperado vs Real)"]
I --> |"Loop de Feedback"| A

Ao sistematizar essa série de passos — desde a coleta de dados do GSC e GA4, passando pela seleção de alvos baseada em análise e otimização de conteúdo via PNL, até ao monitoramento dos resultados — o blog torna-se um ativo que continua crescendo de forma automática.

8. Conclusão e perspectivas futuras

Reescrever artigos técnicos utilizando o Google Search Console não é meramente corrigir texto. Trata-se de uma engenharia avançada que faz pleno uso de dados e modelos matemáticos para apresentar uma solução otimizada para a caixa-preta que é o algoritmo do motor de busca.

Resumindo os métodos explicados neste artigo:

Calcular a disparidade entre a CTR esperada e a CTR real para identificar artigos com um grande impacto para correção.
Extrair automaticamente dados de desempenho utilizando a API do GSC e Python.
Integrar com os dados de engajamento do GA4 no BigQuery e corrigir o corpo dos artigos com altas taxas de rejeição.
Usar a análise PNL com TF-IDF para descobrir lacunas de conteúdo face aos concorrentes e otimizar os cabeçalhos (H2/H3).

As tendências tecnológicas estão em constante evolução. Para responder de forma precisa aos erros e desafios que os leitores enfrentam atualmente, certifique-se de incorporar uma estratégia de reescrita baseada em dados nas suas operações diárias.

Analytics on kenji.blog