The May 19, 2026, Google announced the biggest update to the search engine in 25 years. Search's new AI Mode is built on Gemini 3.5 Flash and accepts text, images, files, and videos., radically transforming how search results are generated, cited, and measured.
For developers, publishers, and SEO specialists managing WordPress sites in production, this change isn't just an algorithmic update—it's a new layer of visibility that requires completely different testing methodologies Compared to the past. A website can rank perfectly in organic search and remain invisible in AI Mode. Or it can be cited as a primary source in hundreds of AI responses without generating a single click measured in Google Search Console.
This article provides a Technical operational roadmap To test your site in Google's new AI Modes, integrate Gemini 3.5 Flash as a citation validation tool, configure real-time monitoring via the Search Console API, and interpret data that Google does not natively expose in the dashboard.
Why Traditional Tests Don't Capture the New Reality of Google Search
Since the public launch of AI Overviews in May 2024, user behavior on Search has changed irreversibly. A study by Seer Interactive based on 25.1 million impressions found that when an AI Overview appears, the organic CTR drops from 1.761% to 0.611%—a decline of 611%. Ahrefs has confirmed that AI Overviews reduce the organic CTR for the #1 position by 58%.
The central problem: Google Search Console aggregates AI Overview data with standard organic data in the default view. When your content is cited within an AI Overview but doesn't receive a click, that citation is invisible in GSC. You could be a primary source in Google's AI response for hundreds of queries and see no evidence in Search Console..
This blind spot is precisely why organizations need to Automated testing and monitoring in parallel operating beyond GSC, using direct APIs and AI models as citability validators.
Step 1: Configure the Search Console API to Filter AI Mode Data
Unlike traditional AI overviews, Starting June 2025, Google AI Mode data will be available in Search Console. This filter displays impressions, clicks, and queries specifically from AI Mode citations — offering the first native view of AI-driven search traffic..
Step 1.1: Generate OAuth 2.0 credentials
- Login Google Cloud Console with the site administrator account
- Create a new project named “AI-Mode-Monitoring”
- Enable the API
Google Search Console API - Create credentials of type OAuth 2.0 Desktop Application
- Download the file
credentials.jsonand save it in a secure folder (not in version)
Step 1.2: Create the data extraction script with Python
This script extracts impressions, clicks, and CTR specific to AI Mode from the last 28 days.
#!/usr/bin/env python3
import os
import json
from datetime import datetime, timedelta
from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
import pickle
# Define the scope of the Search Console API
SCOPES = ['https://www.googleapis.com/auth/webmasters.readonly']
def authenticate_gsc():
"""Authenticate using Google Search Console OAuth 2.0 credentials."""
creds = None
if os.path.exists('token.pickle'):
with open('token.pickle', 'rb') as token:
creds = pickle.load(token)
if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token:
creds.refresh(Request())
else:
flow = InstalledAppFlow.from_client_secrets_file(
'credentials.json', SCOPES)
creds = flow.run_local_server(port=0)
with open('token.pickle', 'wb') as token:
pickle.dump(creds, token)
return creds
def fetch_ai_mode_data(service, site_url, days=28):
"""Retrieves AI Mode data from the Search Console API."""
end_date = datetime.now().date()
start_date = end_date - timedelta(days=days)
request = service.searchanalytics().query(
siteUrl=site_url,
body={
'startDate': start_date.isoformat(),
'endDate': end_date.isoformat(),
'dimensions': ['query'],
'searchType': 'discover', # Filter by AI Mode
'rowLimit': 10000
}
)
response = request.execute()
return response.get('rows', [])
def export_to_json(data, filename='ai_mode_data.json'):
"""Exports the data to JSON for further analysis."""
with open(filename, 'w', encoding='utf-8') as f:
json.dump(data, f, indent=2, ensure_ascii=False)
print(f"Data exported to {filename}")
if __name__ == '__main__':
creds = authenticate_gsc()
service = build('webmasters', 'v3', credentials=creds)
# Replace with your site
SITE_URL = 'https://tuosito.it/'
data = fetch_ai_mode_data(service, SITE_URL)
print(f"Rows retrieved: {len(data)}")
for row in data[:5]:
print(f"Query: {row['keys'][0]} | Impressions: {row['impressions']} | CTR: {row['ctr']:.2%}")
export_to_json(data)
Step 1.3: Automate weekly extraction with Cron
Create a cron job to run the script every Monday at 08:00:
0 8 * * 1 /usr/bin/python3 /path/to/fetch_ai_mode_data.py >> /var/log/ai_mode_monitor.log 2>&1
This guarantees a consistent collection baseline data for month-over-month comparison.
Step 2: Implement Gemini 3.5 Flash as a Citability Validator
Gemini 3.5 Flash is the model powering Google Search's new AI Mode.. It's not a random choice: testing your content directly with the same model that Google uses provides the more accurate validation how your site will be evaluated in AI Mode.
Gemini 3.5 Flash offers frontier-level intelligence optimized for real-world tasks at a higher speed and lower cost. It is designed for the agentic era and excels at deploying sub-agents, multi-step workflows, and long-horizon tasks at scale..
Step 2.1: Obtain Gemini 3.5 Flash API credentials
- Login Google AI Studio
- Generate an API key in “API Keys” (no credit card needed for testing)
- Save the key as an environment variable
export GEMINI_API_KEY="your-key-here"
Step 2.2: Create a script to test block quoteability
This script sends snippets of your content to Gemini 3.5 Flash and evaluates whether the response would naturally quote that source:
#!/usr/bin/env python3
import os
import json
import requests
from typing import List
GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
GEMINI_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:generateContent"
def assess_citability(content_block: str, topic: str) -> dict:
"""
Evaluates whether Gemini 3.5 Flash would naturally cite the content block.
Returns: {'citable': bool, 'reasoning': str, 'confidence': float}
"""
system_prompt = f"""You are a quality evaluator for Google AI Overviews.
Analyze this content block and evaluate:
1. Whether it is self-contained (can be understood in isolation)
2. Whether it contains verifiable and specific facts
3. Whether an AI could cite it as a primary source in a summary response
On the topic: {topic}
Respond in JSON: {{'citable': true/false, 'reasoning': 'brief explanation', 'confidence': 0.0-1.0}}
"""
payload = {
'contents': [{
'parts': [{
'text': f"{system_prompt}nnContent to evaluate:n{content_block}"
}]
}],
'generationConfig': {
'temperature': 0.3,
'maxOutputTokens': 200
}
}
response = requests.post(
f"{GEMINI_URL}?key={GEMINI_API_KEY}",
json=payload
)
if response.status_code != 200:
return {'error': response.json()}
try:
result_text = response.json()['candidates'][0]['content']['parts'][0]['text']
# Parsing JSON from the response
import re
json_match = re.search(r'{.*}', result_text, re.DOTALL)
if json_match:
return json.loads(json_match.group())
except Exception as e:
return {'error': str(e)}
def evaluate_page_citability(url: str, extracted_sections: List[dict]):
"""
Evaluates each section of an extracted page for citability.
sections = [{'text': '...', 'heading': 'H2 Title', 'word_count': 150}, ...]
"""
results = []
for section in extracted_sections:
assessment = assess_citability(
content_block=section['text'],
topic=section['heading']
)
results.append({
'heading': section['heading'],
'word_count': section['word_count'],
'assessment': assessment
})
print(f"[{section['heading']}] Citable: {assessment.get('citable')} (Confidence: {assessment.get('confidence', 'N/A')})")
return results
# Usage example
if __name__ == '__main__':
test_sections = [
{
'heading': 'How to Optimize for AI Overviews',
'text': 'To appear in AI Overviews, content must be self-contained and easily summarized. It is important to structure information into blocks of 50–70 words that directly answer the question. When Google extracts content, it looks for answers that do not require additional interpretation.',
'word_count': 67
},
{
'heading': 'Competitive Benchmarking',
'text': 'Your company has 15 years of historical data on cloud service prices.',
'word_count': 15 # Too short
}
]
results = evaluate_page_citability(
url='https://tuosito.it/articolo',
extracted_sections=test_sections
)
# Save the results
with open('citability_assessment.json', 'w', encoding='utf-8') as f:
json.dump(results, f, indent=2, ensure_ascii=False)
Interpret the results:
- Citable: true + confidence > 0.85 Strong segment for AI citation. Keep this structure.
- citable: true + confidence 0.6-0.85 Good, but add context or entity markup to strengthen it.
- citable: false = The block is vague or generic. Rewrite it with specific, verifiable facts.
Step 3: Real-time AI Visibility Monitoring with Looker Studio Dashboards
For teams with access to Looker Studio, connecting GSC via the Google Search Console connector and building a dashboard that compares AI Overview, AI Mode, and web performance side-by-side on a single dashboard is the most efficient monitoring setup. Date comparison controls can be added to see week-over-week and month-over-month trends without manual export and analysis..
Step 3.1: Prepare the data in Google Sheets
Create a Google Sheet named “AI Mode Monitoring” with this structure:
Date | Query | AI Mode Impressions | AI Mode Clicks | CTR | Average Position | Pages Cited | Notes
2026-05-27 | wordpress security | 245 | 18 | 7.3% | 1.2 | 3 | First baseline data
...
Connect this sheet directly to GSC via Google Data Connector, or import via API every Monday.
Step 3.2: Build the Looker Studio Dashboard
- Login Looker Studio (formerly Data Studio)
- Create a new report
- Add data source: Google Search Console (select site)
- Add a scorecard for “AI Mode Impressions last 28 days”
- Add a line graph for “CTR Trend: AI Mode vs. Traditional Web” (last 90 days)
- Add a table for “Top 10 AI Mode Queries” with columns: Query, Impressions, CTR, Cited Pages
- Add a date selection filter to allow custom comparisons.
Critical metric to monitor weekly:
"AI Citation Rate" = (Queries with AI Override linking to your site) / (Total Queries with AI Override)
Review AI Overview impressions compared to web clicks for the top 20 queries that generate impressions. Flag any queries where web clicks have decreased by more than 20% week-over-week while AI Overview impressions have remained stable or increased.
Step 4: Implement Structured Citeability Tracking with Schema Markup
Restructure the content into self-contained, citable blocks. Each section must fully answer one question, so an AI can cleanly extract it into a summary..
Clear answer blocks (answer-first principle, direct 50-70 word response at the beginning), clean structure with lists and tables, strong entities and consistent author profiles, trustworthy sources, and clean schema markup. Only the combination increases the probability of appearing as a citable source. Schema.org for core entities: Article, FAQPage, HowTo, Product, Organization, Person. The cleaner the semantic markup, the higher the probability of being picked up by AI..
WordPress HTML Implementation
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "How can I test my site in Google's AI Modes?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Utilize the Search Console API to filter AI Mode data, integrate Gemini 3.5 Flash to validate content citeability, and monitor real-time impressions with Looker Studio. This approach provides complete visibility into how your site appears in Google's AI responses."
}
}
]
}
{
"@context": "https://schema.org",
"@type": "HowTo",
"name": "How to Configure the Search Console API for AI Mode",
"step": [
{
"@type": "HowToStep",
"name": "Generate OAuth 2.0 Credentials",
"text": "Access the Google Cloud Console, create a new project, enable the Google Search Console API, and create desktop credentials."
},
{
"@type": "HowToStep",
"name": "Create Python Extraction Script",
"text": "Use the googleapiclient library to authenticate and fetch AI Mode data for the past 28 days."
}
]
}
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "How to Test Your Site in Google's New AI Modes",
"author": {
"@type": "Organization",
"name": "AI Publisher WP",
"url": "https://aipublisherwp.com"
},
"datePublished": "2026-05-27",
"dateModified": "2026-05-27",
"articleSection": "Guides & Tutorials",
"keywords": "Google AI Mode, Search Console API, Gemini 3.5 Flash, AI Overview Tracking"
}
WordPress integrates these schemes via WordPress AI Experiments Plugin specialized schema plugins like Rank Math SEO o Yoast SEO Premium.
Step 5: Create Quoted Changes Alerts with Slack + Google Cloud Functions
The shift to AI search is not a one-time event. Google continues to expand AI Overview coverage to new query types, test AI Mode more broadly, and refine which pages receive citations. Effective monitoring requires a cadence and alert system that flags significant changes before they turn into major traffic losses. GSC data, combined with the right monitoring workflow, provides the foundation.
Step 5.1: Create a Cloud Function for weekly citability calculation
import functions_framework
import requests
import json
from datetime import datetime, timedelta
@functions_framework.http
def check_citability_change(request):
"""
Compares this week's citation rate with last week's.
If the drop exceeds 10%, sends an alert to Slack.
"""
SLACK_WEBHOOK = os.getenv('SLACK_WEBHOOK_URL')
# Retrieve data for the current and previous weeks
this_week_citations = fetch_citation_rate(days_back=7)
last_week_citations = fetch_citation_rate(days_back=14, days_before=7)
change_percent = ((this_week_citations - last_week_citations) / last_week_citations) * 100
# If the decline exceeds 10%, send an alert
if change_percent < -10:
message = {
'text': f'⚠️ Citation Rate Decline',
'blocks': [
{
'type': 'section',
'text': {
'type': 'mrkdwn',
'text': f'*AI Overview Citation Rate:* {last_week_citations:.1%} → {this_week_citations:.1%}n*Change:* {change_percent:.1f}%n*Date:* {datetime.now().strftime("%Y-%m-%d")}'
}
}
]
}
response = requests.post(SLACK_WEBHOOK, json=message)
return ('Alert sent', 200)
return ('No significant change', 200)
Step 5.2: Schedule the Cloud Function with Cloud Scheduler
- Login Google Cloud Console
- Go up Cloud Scheduler Create a new job
- Frequency:
0 10 * * 1(every Monday at 10:00 AM) - URL
https://region-project.cloudfunctions.net/check-citability-change - Authentication: Service Account with roles
Cloud Functions Invoker
You will now receive weekly Slack notifications if your site's citation rate in AI Mode results suddenly drops.
Step 6: Correlate AI Citation Data with Business Metrics
Traffic from AI has a 4.4x higher conversion rate than traditional organic search, but you can't measure citation rates, compare competitors, or prove ROI to your board.. However, the raw data is insufficient.
Business metrics to track alongside AI Citation data:
- Citation Rate Trend: AI Mode queries that mention your site (baseline: 20% for strong sites)
- Brand Direct Traffic Increase in direct searches for “[brand name]” after citation in AI Overview
- Content Freshness Score % pages updated in the last 30 days (important for AI citability)
- E-E-A-T Signal Author byline visibility, date metadata, expertise keywords
- Share of Voice in AI: (Tue citation / Total AI Overviews triggered) × 100
Create a Google Sheet that correlates this data with Google Analytics 4 to measure the true impact of AI visibility on your business.
FAQ Section
Question 1: How can I distinguish between AI Overview impressions and AI Mode impressions in Google Search Console?
Starting June 2025, Google AI Mode data will be available in Search Console. This filter shows impressions, clicks, and queries specifically from AI Mode citations—offering the first native view of AI-driven search traffic.. For traditional AI Overviews, GSC does not provide a native filter; you have to use query regex (e.g., filter for queries with 6+ conversational words) as an indirect proxy.
Question 2: What is the minimum word count for a block of content to be citable according to Gemini 3.5 Flash?
Each section must fully answer one question, so that an AI can extract it cleanly into a summary.. In practice, the minimum is 40-50 words For a complete response, the ideal length is 50-80 words. Blocks under 30 words are rarely cited because they lack sufficient context. Blocks over 150 words are generally broken into AI excerpts, meaning less likelihood of fully attributing your source.
Question 3: Do I need to optimize specifically for AI Mode, or does traditional SEO remain valid?
SEO best practices continue to be relevant because Google Search's generative features are rooted in Search's core ranking and quality systems. You can apply the same fundamental SEO best practices for AI features as you do for Google Search overall: ensure the page meets technical requirements, adhere to Search policies, and focus on key best practices like creating helpful, trustworthy, people-first content.. AI optimization does not replace SEO; extend.
Question 4: How do I know if the traffic drop is due to AI Overviews or a Google update?
Use this three-level method:
- Filter conversational queries (6+ words) In GSC, compare the CTR of this segment with the short-tail segment. If the CTR only drops for long-tail, it's AI Overviews.
- Monitor AI Citation Rate with a weekly script (Step 2). If the impression share is stable or growing while the CTR plummets, it's AI (positive). If both are declining, it's a ranking action (negative).
- Manually check the top 10-15 queries directly on Google. If you see an AI Overview referencing your site, the drop is due to AI Overviews, not an algorithmic update.
Question 5: When should I use Gemini 3.5 Flash vs. the Search Console API for monitoring?
Gemini 3.5 Flash For evaluate the quality and citable quality of the new content before publishing. It's a validation tool, not a tracking tool.
Search Console API For measure the volume and the trend real-time quotes. It is your authoritative record system.
Use them together: Gemini for pre-publication validation, GSC API for post-publication monitoring.
Conclusion: From Blind Spot to Competitive Advantage
On May 19, 2026, Google revolutionized the search engine — the biggest change in over 25 years. This is not a minor algorithmic update. It is a paradigm shift where Visibility in AI Mode has become a completely new ranking category.
Following this step-by-step guide, you can:
- Extract AI Mode raw data that Search Console API remain invisible in the traditional dashboard
- Validate citability from your content using the same model (Gemini 3.5 Flash) that Google uses for AI responses
- Real-time monitoring Quotes, citation rate, and week-over-week changes with Looker Studio
- Receive automatic alerts when the quote rate falls by more than 10%
- Correlate AI visibility with real business metrics (traffic, conversions, brand recognition)
For those managing WordPress in production, this approach is particularly critical. Unlike static sites, WordPress needs to integrate with API monitoring, Slack webhooks, and data extracts—requiring technical skills but offering insights that competitors aren't yet tracking.
Discover how build Entity Authority to be cited by ChatGPT, Perplexity, and Google AI with a proven strategy. Or explore how Configure the WordPress AI Client Connector to automate the validation of citability directly into your editorial workflow.
In 2026, the Google Search Console blind spot is no longer an excuse. The data is there—you just need to know how to extract it, interpret it, and use it to stay ahead of the competition.
