Fixing Error 400: mismatch in redirect_uri When importing reviews from Google Business into Python

Overcoming OAuth 2.0 Redirect URI Issues in Google Reviews API Integration

When integrating Google Business Reviews into Python, many developers encounter the common error "Error 400: redirect_uri_mismatch." This issue arises due to a misalignment between the redirect URI in the OAuth 2.0 settings and what is specified in the Google Cloud Console. The error can prevent access to the Google Reviews API, which is crucial for retrieving customer feedback programmatically.

Google’s OAuth 2.0 policy is strict, requiring a precise match between the configured redirect URI and the one used during authentication. Failure to properly configure this can lead to frustration, especially when the redirect port number changes frequently, as many developers report. Understanding this issue is essential to ensure a smooth API connection and avoid hitting this roadblock.

In this article, we’ll walk through the steps to resolve the redirect_uri_mismatch error when accessing Google Business Reviews. By carefully configuring your OAuth credentials, we’ll eliminate this issue and enable you to fetch reviews with ease. The solution involves correctly setting the redirect URI and aligning it with the localhost environment used for development.

Whether you're fetching reviews to analyze business performance or to display them on your website, understanding how to resolve this error will save time and ensure successful API interaction. Follow these steps to fix the mismatch and access your Google Business reviews without interruptions.

Understanding the OAuth 2.0 Process for Accessing Google Reviews API

The Python scripts provided above are designed to fetch Google Business Reviews using the Google My Business API. The first step involves setting up OAuth 2.0 authorization, which is required to interact with Google’s APIs securely. This process starts by specifying your OAuth client secrets in a JSON file, which contains the credentials for your Google Cloud project. These credentials are critical for establishing secure access, and the redirect URI must match the one configured in the Google Cloud Console. A mismatch can cause an error like "Error 400: redirect_uri_mismatch."

Once the credentials are loaded, the script initiates an OAuth flow using the InstalledAppFlow. This flow launches a local server (in this case, on port 8080) to handle the user authorization. When the user grants permission, the script receives an access token, which is necessary for making authorized requests to the Google Reviews API. This process is automated and handled by the flow.run_local_server method, ensuring that the credentials are securely stored and used for API requests. Logging mechanisms like loguru are employed to track the flow and ensure that any issues encountered are logged clearly for debugging.

After successfully obtaining the credentials, the script establishes a session using the requests library. This session includes the access token in its headers, which is required for authentication when making API calls to Google. The script constructs the correct API endpoint URL using your business account ID and location ID. By sending a GET request to the URL, the script attempts to fetch reviews for the specified business location. It also includes error handling to catch HTTP errors, such as incorrect credentials or permissions, ensuring that any problems encountered during the request are managed efficiently.

The response from the Google Reviews API is parsed as a JSON object, which contains the reviews for the business location. If the request is successful, the reviews are printed to the console, and the script logs a success message. This modular approach ensures that the process is easily repeatable and can be customized for different locations or accounts. Furthermore, by maintaining a clear structure with session management and error handling, the script optimizes security and performance when working with the Google Reviews API. This allows developers to efficiently access and manage customer reviews for analysis or display.

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)

Solving OAuth Redirect Issues in Google APIs for Python Integration

One critical aspect often overlooked when integrating Google APIs into Python applications is the precise configuration of the redirect URI. This setting is vital for OAuth 2.0 authentication, and a mismatch in this URI often results in the "Error 400: redirect_uri_mismatch" error. Google’s authentication process is stringent to ensure that the flow is secure and follows best practices. Therefore, developers need to ensure that the redirect URI configured in the Google Cloud Console exactly matches the one being used in their application code.

Another important aspect is understanding how ports work in the OAuth flow, especially when working in a local environment. Developers frequently encounter changing port numbers (like the "52271" error mentioned earlier) when using tools like flow.run_local_server(). It’s advisable to fix the port number (e.g., 8080) to avoid mismatches, and this can be done by explicitly passing the port number in the code. This not only ensures consistency but also prevents errors that arise due to dynamic port assignment.

Additionally, managing your OAuth 2.0 credentials securely is essential. The JSON file containing client secrets must be stored in a secure location, and access tokens should be refreshed periodically. Keeping these tokens updated ensures that the API calls remain valid, as expired tokens can also cause authentication issues. Overall, careful management of your authentication flow ensures smoother integration and eliminates common pitfalls like the redirect URI mismatch error.