Motores de busca modernos não interpretam páginas web como simples sacos de palavras. Desde a introdução do Knowledge Graph e a transição arquitetural de strings para coisas, o Google avalia documentos a partir de entidades nomeadas, seus atributos e suas relações estruturais. Otimizar conteúdo ignorando esse princípio gera textos inflados com sinônimos forçados, mas com baixa capacidade de sustentar autoridade temática perante algoritmos de Processamento de Linguagem Natural (PLN).
A auditoria de entity seo python salience permite auditar com rigor matemático como o Google processa cada termo dentro da hierarquia sintática do seu texto. Utilizando a Google Natural Language API via Python, você extrai o Salience Score de cada entidade, descobre se o tema central realmente ocupa o núcleo de atenção do documento e mapeia os déficits semânticos que impedem suas páginas de conquistarem as primeiras posições da SERP.
O que é salience score na Google Natural Language API
O Salience Score é uma métrica decimal calculada entre 0.0 e 1.0 que quantifica a centralidade ou relevância de uma entidade em relação ao documento como um todo. A soma das pontuações de saliência de todas as entidades identificadas em um texto normaliza para 1.0.
Se o seu objetivo é ranquear para um determinado assunto, a entidade correspondente precisa atingir a maior saliência relativa do texto, ou ao menos figurar no topo do cluster semântico primário. Quando um artigo trata de “bancos de dados distribuídos”, mas cita tantas marcas, ferramentas secundárias e analogias que a entidade primária atinge apenas 0.04 de saliência, os classificadores do Google concluem que o documento aborda outros assuntos de forma fragmentada.
A contagem tradicional de ocorrências falha porque não pondera a gramática profunda. Um termo pode se repetir quinze vezes em notas de rodapé ou orações adjetivas e ter saliência menor do que uma entidade citada apenas duas vezes, porém situada no sujeito da oração principal do primeiro parágrafo.
Mecânica da saliência: como o Google processa a estrutura do texto
A Google Natural Language API combina modelos linguísticos e regras de gramática de dependência para computar a saliência. Quatro fatores determinam o peso final de cada entidade.
1. Posição e dependência sintática
A API decompõe o texto em árvores de dependência sintática (dependency trees). Entidades posicionadas como sujeito nominal (nsubj) na oração principal recebem maior carga de saliência do que entidades alocadas como objeto direto (dobj), objeto preposicional (pobj) ou complementos em orações subordinadas.
Quando você escreve:
O Python analisa grandes volumes de dados no BigQuery.
A entidade “Python” ocupa a posição de sujeito ativo, recebendo a primazia de atenção estrutural. Em contrapartida, “BigQuery” atua como objeto preposicional, recebendo fração menor de saliência.
2. Resolução de correferências (anaphora resolution)
Modelos avançados de PLN identificam quando pronomes e variações nominais apontam para a mesma entidade. Na frase “O Python é uma linguagem versátil. Ele processa coleções com rapidez”, o pronome “Ele” é resolvido como referência à entidade “Python”. A frequência com que uma cadeia de correferência é mantida ao longo do documento eleva a pontuação da entidade central.
3. Distribuição posicional no documento
Entidades introduzidas no primeiro terço do documento, especialmente no título, no primeiro parágrafo e nas sentenças iniciais de cada seção, carregam um prior bayesiano mais alto de relevância temática. Quando o tema principal aparece tardiamente, a API dilui seu escore.
4. Conexão com o Knowledge Graph e MIDs
A API tenta reconciliar as entidades extraídas com o banco de dados de entidades do Google. Quando identifica uma correspondência inequívoca, a resposta retorna um identificador único de máquina, conhecido como MID (Machine ID, como /m/05z1_ para Python), acompanhado da URL correspondente na Wikipedia. Entidades com MID validado ancoram o documento diretamente no grafo global de conhecimento do mecanismo de busca.
Por que a densidade de palavras-chave falha frente ao Entity SEO
A busca orientada a palavras-chave considerava repetição léxica e TF-IDF básico. O Entity SEO avalia relações de ontologia e coocorrência tópica.
Quando múltiplos concorrentes publicam conteúdos com tamanhos e contagens de palavras similares, o diferencial que o Google utiliza envolve a densidade de informação factual e a coerência semântica das entidades presentes. Esse princípio conecta-se diretamente ao cálculo de ganho informacional que abordamos no artigo sobre Information Gain SEO com Python.
A tabela abaixo sintetiza a divergência entre a abordagem antiga e a auditoria baseada em entidades:
| Critério | Abordagem por Palavra-chave (Legado) | Auditoria de Entity SEO (Moderno) |
|---|---|---|
| Unidade de medição | Strings de texto e repetição percentual | Entidades conceituais com IDs no Knowledge Graph |
| Avaliação de contexto | Coocorrência simples de palavras vizinhas | Análise de dependência sintática e grafos semânticos |
| Relevância no documento | Frequência do termo (TF-IDF) | Salience Score normalizado (0.0 a 1.0) |
| Ambiguidade | Confunde termos polissêmicos | Desambiguação via contexto e atributos da entidade |
| Otimização on-page | Inserção mecânica de termos em seções | Reestruturação de papéis gramaticais e sujeito ativo |
Configuração do ambiente e autenticação no Google Cloud
Para rodar a auditoria em Python, você precisa de um projeto no Google Cloud Platform com a Cloud Natural Language API habilitada e de credenciais de serviço.
Passo 1: Criar a Service Account
- Acesse o console do Google Cloud Platform.
- Crie um novo projeto ou selecione um existente.
- No menu lateral, acesse APIs e Serviços > Biblioteca e habilite a Cloud Natural Language API.
- Vá em IAM e administração > Contas de serviço e crie uma conta com permissão de visualizador básico.
- Gere uma chave privada no formato JSON e faça o download seguro para seu ambiente local.
Passo 2: Instalação das dependências
Instale as bibliotecas oficiais no seu ambiente virtual:
pip install google-cloud-language pandas requests beautifulsoup4Defina a variável de ambiente apontando para o seu arquivo de credenciais antes de executar os scripts:
export GOOGLE_APPLICATION_CREDENTIALS="/caminho/para/suas-credenciais.json"Pipeline em Python: extração de entidades e cálculo de saliência
O código a seguir encapsula a comunicação com a API, extrai o texto limpo a partir de uma URL ou string, submete o conteúdo ao endpoint de analyze_entities e retorna um DataFrame estruturado com nome, tipo, Salience Score, MID e quantidade de menções.
import os
from google.cloud import language_v1
import pandas as pd
import requests
from bs4 import BeautifulSoup
def fetch_clean_article_text(url: str) -> str:
"""Extrai e limpa o texto principal do artigo a partir de uma URL."""
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
}
response = requests.get(url, headers=headers, timeout=15)
response.raise_for_status()
soup = BeautifulSoup(response.text, "html.parser")
# Remove elementos irrelevantes para analise textual
for tag in soup(["script", "style", "nav", "header", "footer", "aside"]):
tag.decompose()
article_node = soup.find("article") or soup.find("main") or soup.body
if not article_node:
return ""
paragraphs = [p.get_text().strip() for p in article_node.find_all("p")]
return "\n\n".join(p for p in paragraphs if len(p) > 25)
def analyze_entities_salience(text: str, language: str = "pt-BR") -> pd.DataFrame:
"""Envia o texto para a Google Natural Language API e calcula a salience."""
client = language_v1.LanguageServiceClient()
document = language_v1.Document(
content=text,
type_=language_v1.Document.Type.PLAIN_TEXT,
language=language,
)
# Executa a analise de entidades
response = client.analyze_entities(document=document)
records = []
for entity in response.entities:
metadata = dict(entity.metadata)
records.append(
{
"name": entity.name,
"type": language_v1.Entity.Type(entity.type_).name,
"salience": round(entity.salience, 4),
"mid": metadata.get("mid", ""),
"wikipedia_url": metadata.get("wikipedia_url", ""),
"mentions_count": len(entity.mentions),
}
)
df = pd.DataFrame(records)
if df.empty:
return df
return df.sort_values(by="salience", ascending=False).reset_index(drop=True)
if __name__ == "__main__":
url_alvo = "https://cayogalotti.com.br/blog/entity-seo-python-salience/"
print(f"Coletando texto de: {url_alvo}")
conteudo = fetch_clean_article_text(url_alvo)
if conteudo:
df_entidades = analyze_entities_salience(conteudo)
print("\nTop 10 Entidades por Salience Score:")
print(
df_entidades[
["name", "type", "salience", "mentions_count", "mid"]
].head(10)
)Ao executar o script, você obtém uma visão clara de como a API hierarquiza seu artigo. Se o nome da sua tecnologia principal aparece em oitavo lugar com 0.02 de saliência, o texto possui um erro estrutural de hierarquia.
Comparativo contra a concorrência: mapeando o déficit de saliência
A utilidade do Salience Score se consolida ao contrastar a distribuição semântica da sua página contra os concorrentes que já ranqueiam no topo da SERP para a palavra-chave visada.
O script a seguir compara a sua URL com URLs concorrentes e calcula duas variáveis:
- O déficit de saliência da entidade alvo.
- As entidades ausentes no seu texto que possuem alta relevância média nos concorrentes.
import pandas as pd
def benchmark_entity_gap(
my_url: str, competitor_urls: list[str], target_entity_name: str
) -> dict:
"""Compara o salience score e descobre entidades que faltam no seu conteudo."""
# Processa o proprio conteudo
print(f"Processando URL própria: {my_url}")
my_text = fetch_clean_article_text(my_url)
my_df = analyze_entities_salience(my_text)
# Processa concorrentes
comp_dfs = []
for comp_url in competitor_urls:
print(f"Processando concorrente: {comp_url}")
try:
c_text = fetch_clean_article_text(comp_url)
c_df = analyze_entities_salience(c_text)
comp_dfs.append(c_df)
except Exception as err:
print(f"Falha ao coletar {comp_url}: {err}")
# Salience da entidade alvo no proprio texto
target_match = my_df[
my_df["name"].str.lower() == target_entity_name.lower()
]
my_salience = (
target_match["salience"].values[0] if not target_match.empty else 0.0
)
# Salience media nos concorrentes
comp_saliences = []
all_comp_entities = []
for c_df in comp_dfs:
c_match = c_df[c_df["name"].str.lower() == target_entity_name.lower()]
s = c_match["salience"].values[0] if not c_match.empty else 0.0
comp_saliences.append(s)
# Coleta todas entidades dos concorrentes com salience relevante (> 0.01)
relevant_entities = c_df[c_df["salience"] >= 0.01][
["name", "type", "salience", "mid"]
]
all_comp_entities.append(relevant_entities)
avg_comp_salience = (
sum(comp_saliences) / len(comp_saliences) if comp_saliences else 0.0
)
# Identificar entidades ausentes
if all_comp_entities:
merged_comp = pd.concat(all_comp_entities)
grouped_comp = (
merged_comp.groupby(["name", "type", "mid"])["salience"]
.mean()
.reset_index()
)
grouped_comp = grouped_comp.sort_values(
by="salience", ascending=False
)
my_entities_set = set(my_df["name"].str.lower())
missing_entities = grouped_comp[
~grouped_comp["name"].str.lower().isin(my_entities_set)
]
else:
missing_entities = pd.DataFrame()
return {
"target_entity": target_entity_name,
"my_salience": round(my_salience, 4),
"competitor_avg_salience": round(avg_comp_salience, 4),
"salience_gap": round(avg_comp_salience - my_salience, 4),
"missing_top_entities": missing_entities.head(10),
}
if __name__ == "__main__":
resultado = benchmark_entity_gap(
my_url="https://cayogalotti.com.br/blog/entity-seo-python-salience/",
competitor_urls=[
"https://concorrente-exemplo-a.com.br/artigo-seo/",
"https://concorrente-exemplo-b.com.br/entity-seo-guia/",
],
target_entity_name="Entity SEO",
)
print("\n--- RESUMO DE SALIÊNCIA ---")
print(f"Entidade Alvo: {resultado['target_entity']}")
print(f"Saliência da sua página: {resultado['my_salience']}")
print(
f"Média dos concorrentes: {resultado['competitor_avg_salience']}"
)
print(f"Déficit (Gap): {resultado['salience_gap']}")
print("\n--- TOP ENTIDADES AUSENTES PRESENTES NOS CONCORRENTES ---")
print(resultado["missing_top_entities"])Se o relatório apontar um gap positivo significativo (por exemplo, os concorrentes apresentam média de 0.18 para a entidade alvo e sua página registra apenas 0.05), seu texto está sofrendo de dispersão tópica.
Como reestruturar o texto para elevar o salience score
Corrigir a saliência de uma página não significa repetir o termo vinte vezes no texto. A intervenção exige ajustes na engenharia sintática das frases.
1. Converta orações passivas em voz ativa com a entidade no sujeito
A API atribui maior peso ao sujeito nominal (nsubj). Observe a diferença:
- Sintaxe fraca: “Diversos tipos de análises e auditorias técnicas profundas podem ser realizadas pelo profissional com o uso do Python.” (Aqui, “diversos tipos” e “profissional” competem pelo núcleo sintático).
- Sintaxe forte: “O Python executa auditorias profundas de Entity SEO ao analisar a dependência sintática do texto.” (A entidade “Python” comanda a oração como sujeito ativo).
2. Elimine orações subordinadas que introduzem entidades distraidoras
Evite iniciar parágrafos com longas introduções sobre assuntos tangenciais. Quando você escreve parágrafos inteiros elogiando o Vale do Silício ou discorrendo sobre a história da internet antes de falar do tema central, entidades como “Estados Unidos” e “Internet” consomem percentuais da distribuição de saliência que deveriam pertencer ao tópico central.
3. Fortaleça os cabeçalhos H2 e as sentenças de abertura
O modelo de PLN considera a vizinhança sintática imediata das quebras de seção. A primeira frase após um H2 deve declarar explicitamente a relação entre a entidade principal da seção e o conceito geral abordado.
4. Conecte dados estruturados via Schema Markup
O conteúdo textual é validado pelo código on-page. Para consolidar o reconhecimento de entidades e seus MIDs no Knowledge Graph, implemente marcação semântica com referências cruzadas. Utilize as propriedades about e sameAs apontando para os IDs canônicos da Wikipedia e Wikidata, conforme detalhado no nosso guia técnico de Schema Markup B2B com JSON-LD.
Exemplo de injeção complementar no schema da página:
{
"@context": "https://schema.org",
"@type": "TechArticle",
"headline": "Auditoria de Entity SEO com Python e Google Natural Language API",
"about": [
{
"@type": "Thing",
"name": "Search Engine Optimization",
"sameAs": "https://en.wikipedia.org/wiki/Search_engine_optimization"
},
{
"@type": "Thing",
"name": "Natural Language API",
"sameAs": "https://cloud.google.com/natural-language"
}
]
}O papel das entidades no Google AI Overviews e motores generativos
Com a consolidação das buscas conversacionais e dos resumos automáticos gerados por IA, o ranqueamento depende de como os sistemas de busca sintetizam respostas usando Retrieval-Augmented Generation (RAG).
Motores de busca não leem parágrafos corridos para formular sínteses em AI Overviews. Eles extraem triplas semânticas (sujeito, predicado e objeto) a partir de passagens de alta confiança. Uma página cujas entidades possuem alta saliência e relações gramaticais claras fornece fragmentos ideais para compor citações no Google AI Overviews e ferramentas como o Perplexity. Para aprofundar nessa disciplina, confira nossa análise sobre Generative Engine Optimization (GEO).
Se a relação entre a entidade e seu atributo for ambígua no texto, o extrator do RAG descarta a passagem por falta de acurácia factual.
Escalando auditorias de entidades com BigQuery e Search Console
Realizar auditorias manuais URL por URL funciona para páginas estratégicas de conversão. Em portais com milhares de URLs, o processo precisa de automação contínua.
O fluxo ideal combina os dados de tráfego orgânico com as métricas da Natural Language API:
- Exporte os dados de consultas, URLs e impressões através do pipeline documentado em Search Console API com Python e BigQuery.
- Isole as URLs que possuem impressões altas em posições intermediárias (posições 5 a 15) para consultas ricas em entidades.
- Dispare uma rotina assíncrona em Python para processar o conteúdo dessas páginas na Natural Language API.
- Armazene as métricas de Salience Score e as entidades ausentes em uma tabela dedicada no BigQuery.
- Gere relatórios automatizados destacando páginas que sofrem de canibalização semântica ou diluição da entidade principal.
Esse procedimento transforma uma análise qualitativa em um indicador mensurável que direciona revisões editoriais com base em estatísticas concretas.
Implementando a rotina de auditoria no fluxo editorial
Auditar o Salience Score encerra o ciclo de suposições no SEO técnico on-page. Em vez de depender de checklists genéricos de plugins que contam repetições mecânicas de palavras, sua equipe passa a operar com os mesmos modelos de processamento que o Google aplica no rastreamento e na indexação.
O roteiro de aplicação imediata segue três etapas:
- Extraia e audite a sua URL prioritária com o pipeline em Python demonstrado neste artigo.
- Identifique quais entidades secundárias estão canibalizando a saliência do seu tópico principal e reescreva as frases colocando o conceito central no sujeito da oração ativa.
- Compare seu grafo de entidades contra as três primeiras páginas da SERP e incorpore as entidades conceituais ausentes por meio de definições diretas e estruturadas.
Essa abordagem confere precisão técnica ao conteúdo, alinha seu domínio às exigências do Knowledge Graph e constrói autoridade tópica sustentável.