Correção do erro 400: incompatibilidade em redirect_uri ao importar comentários do Google Business para Python

Superando problemas de URI de redirecionamento do OAuth 2.0 na integração da API do Google Reviews

Ao integrar o Google Business Reviews ao Python, muitos desenvolvedores encontram o erro comum “Erro 400: redireccionamento_uri_mismatch”. Esse problema surge devido a um desalinhamento entre o URI de redirecionamento nas configurações do OAuth 2.0 e o que está especificado no Console do Google Cloud. O erro pode impedir o acesso à API do Google Reviews, que é crucial para recuperar feedback dos clientes de forma programática.

A política OAuth 2.0 do Google é rigorosa, exigindo uma correspondência precisa entre o URI de redirecionamento configurado e aquele usado durante a autenticação. A falha em configurar isso corretamente pode levar à frustração, especialmente quando o número da porta de redirecionamento muda com frequência, como relatam muitos desenvolvedores. Compreender esse problema é essencial para garantir uma conexão de API tranquila e evitar esse obstáculo.

Neste artigo, percorreremos as etapas para resolver o erro redirect_uri_mismatch ao acessar o Google Business Reviews. Ao configurar cuidadosamente suas credenciais OAuth, eliminaremos esse problema e permitiremos que você obtenha avaliações com facilidade. A solução envolve definir corretamente o URI de redirecionamento e alinhá-lo com o ambiente localhost usado para desenvolvimento.

Esteja você buscando avaliações para analisar o desempenho do negócio ou exibi-las em seu site, entender como resolver esse erro economizará tempo e garantirá uma interação bem-sucedida da API. Siga estas etapas para corrigir a incompatibilidade e acessar suas avaliações do Google Business sem interrupções.

Compreendendo o processo OAuth 2.0 para acessar a API Google Reviews

Os scripts Python fornecidos acima foram projetados para buscar avaliações de empresas do Google usando a API do Google Meu Negócio. A primeira etapa envolve a configuração da autorização OAuth 2.0, necessária para interagir com as APIs do Google de forma segura. Esse processo começa especificando os segredos do cliente OAuth em um arquivo JSON, que contém as credenciais do seu projeto do Google Cloud. Essas credenciais são essenciais para estabelecer acesso seguro e o redirecionar URI deve corresponder ao configurado no Console do Google Cloud. Uma incompatibilidade pode causar um erro como “Erro 400: redireccionamento_uri_mismatch”.

Depois que as credenciais são carregadas, o script inicia um fluxo OAuth usando o InstalledAppFlow. Este fluxo lança um servidor local (neste caso, na porta 8080) para tratar a autorização do usuário. Quando o usuário concede permissão, o script recebe um token de acesso, necessário para fazer solicitações autorizadas à API Google Reviews. Esse processo é automatizado e gerenciado pelo método flow.run_local_server, garantindo que as credenciais sejam armazenadas com segurança e usadas para solicitações de API. Mecanismos de registro como loguru são empregados para rastrear o fluxo e garantir que quaisquer problemas encontrados sejam registrados claramente para depuração.

Após obter as credenciais com sucesso, o script estabelece uma sessão usando a biblioteca de solicitações. Esta sessão inclui o token de acesso em seus cabeçalhos, que é necessário para autenticação ao fazer chamadas de API ao Google. O script constrói o URL correto do endpoint da API usando o ID da sua conta comercial e o ID do local. Ao enviar uma solicitação GET para o URL, o script tenta buscar avaliações para o local comercial especificado. Também inclui tratamento de erros para detectar erros HTTP, como credenciais ou permissões incorretas, garantindo que quaisquer problemas encontrados durante a solicitação sejam gerenciados de forma eficiente.

A resposta da API do Google Reviews é analisada como um objeto JSON, que contém os comentários do local da empresa. Se a solicitação for bem-sucedida, as revisões serão impressas no console e o script registrará uma mensagem de sucesso. Essa abordagem modular garante que o processo seja facilmente repetível e possa ser personalizado para diferentes locais ou contas. Além disso, ao manter uma estrutura clara com gerenciamento de sessões e tratamento de erros, o script otimiza a segurança e o desempenho ao trabalhar com a API Google Reviews. Isso permite que os desenvolvedores acessem e gerenciem com eficiência as avaliações dos clientes para análise ou exibição.

import requests
from google_auth_oauthlib.flow import InstalledAppFlow
from loguru import logger as log
# Replace with your actual Google Business account and location IDs
my_business_account_id = "YOUR_ACCOUNT_ID"
location_id = "YOUR_LOCATION_ID"
# Path to your OAuth 2.0 Client Secret JSON file
GCP_CREDENTIALS_PATH = "path/to/your/google_review_client.json"
# Set a consistent redirect URI
redirect_uri = "http://localhost:8080/"
# Setup the OAuth 2.0 flow with required scopes
flow = InstalledAppFlow.from_client_secrets_file(
    GCP_CREDENTIALS_PATH,
    scopes=["https://www.googleapis.com/auth/business.manage"],
    redirect_uri=redirect_uri)
# Run OAuth flow to obtain credentials
credentials = flow.run_local_server(port=8080)
log.debug(f"Credentials: {credentials}")
# Setup the API request session
session = requests.Session()
session.headers.update({"Authorization": f"Bearer {credentials.token}"})
# Construct the API endpoint URL
url = f"https://mybusiness.googleapis.com/v4/accounts/{my_business_account_id}/locations/{location_id}/reviews"
# Make API request and handle potential errors
try:
    response = session.get(url)
    response.raise_for_status()
    reviews = response.json()
    print("Reviews fetched successfully.")
    print(reviews)
except requests.exceptions.HTTPError as http_err:
    log.error(f"HTTP error: {http_err}")
except Exception as err:
    log.error(f"Unexpected error: {err}")

# Step 1: Open Google Cloud Console
# Step 2: Navigate to your project and go to "APIs & Services" > "Credentials"
# Step 3: Edit the OAuth 2.0 Client IDs settings
# Step 4: In "Authorized redirect URIs", add "http://localhost:8080/"
# Step 5: Save your changes
# After setting the correct redirect URI, re-run your Python script
# This ensures the OAuth 2.0 flow will use the correct URI during authentication

from flask import Flask, redirect, request, session, url_for
from google_auth_oauthlib.flow import Flow
# Flask setup
app = Flask(__name__)
app.secret_key = "your_secret_key"
# Path to OAuth 2.0 Client Secret JSON
GCP_CREDENTIALS_PATH = "google_review_client.json"
@app.route("/authorize")
def authorize():
    flow = Flow.from_client_secrets_file(
        GCP_CREDENTIALS_PATH,
        scopes=["https://www.googleapis.com/auth/business.manage"],
        redirect_uri=url_for("oauth2callback", _external=True)
    )
    authorization_url, _ = flow.authorization_url()
    return redirect(authorization_url)
@app.route("/oauth2callback")
def oauth2callback():
    flow = Flow.from_client_secrets_file(
        GCP_CREDENTIALS_PATH,
        scopes=["https://www.googleapis.com/auth/business.manage"],
        redirect_uri=url_for("oauth2callback", _external=True)
    )
    flow.fetch_token(authorization_response=request.url)
    session["credentials"] = flow.credentials
    return redirect("/reviews")
# Run the Flask server
if __name__ == "__main__":
    app.run("localhost", 8080)

Resolvendo problemas de redirecionamento OAuth em APIs do Google para integração com Python

Um aspecto crítico frequentemente esquecido ao integrar APIs do Google em aplicativos Python é a configuração precisa do redirecionar URI. Essa configuração é vital para a autenticação OAuth 2.0, e uma incompatibilidade nesse URI geralmente resulta no erro "Erro 400: redirect_uri_mismatch". O processo de autenticação do Google é rigoroso para garantir que o fluxo seja seguro e siga as práticas recomendadas. Portanto, os desenvolvedores precisam garantir que o URI de redirecionamento configurado no Console do Google Cloud corresponda exatamente àquele que está sendo usado no código do aplicativo.

Outro aspecto importante é entender como as portas funcionam no fluxo OAuth, principalmente quando se trabalha em ambiente local. Os desenvolvedores frequentemente encontram alterações nos números de porta (como o erro "52271" mencionado anteriormente) ao usar ferramentas como flow.run_local_server(). É aconselhável corrigir o número da porta (por exemplo, 8080) para evitar incompatibilidades, e isso pode ser feito passando explicitamente o número da porta no código. Isso não apenas garante consistência, mas também evita erros que surgem devido à atribuição dinâmica de portas.

Além disso, gerenciar seu OAuth 2.0 credentials com segurança é essencial. O arquivo JSON que contém os segredos do cliente deve ser armazenado em um local seguro e os tokens de acesso devem ser atualizados periodicamente. Manter esses tokens atualizados garante que as chamadas de API permaneçam válidas, pois tokens expirados também podem causar problemas de autenticação. No geral, o gerenciamento cuidadoso do seu fluxo de autenticação garante uma integração mais suave e elimina armadilhas comuns, como o erro de incompatibilidade de URI de redirecionamento.