DEV Community: MarkoMetrics

Free SEO & AI Search Audit Chrome Extension | MarkoMetrics

MarkoMetrics — Sat, 10 Oct 2026 17:24:19 +0000

TL;DR:

The MarkoMetrics Chrome extension lets you audit any web page for on-page SEO, technical SEO, content, and GEO/AEO. The scan takes a few seconds, requires no account, and gives you an overall score with ranked findings. You can also generate fixes using your own OpenAI, Anthropic, or Google Gemini API key. Scanning is free and unlimited.

What is the MarkoMetrics SEO extension?

The MarkoMetrics Chrome extension is a browser-based SEO self-audit tool.

Open any web page, click the MarkoMetrics icon, and the extension opens a side panel with an overall score, four category scores, and a list of things that need attention.

Each finding includes a plain-language recommendation. For findings that can be fixed automatically, you can use AI to generate the fix.

The important part is that you do not have to submit a URL and wait for an audit report. The page is checked directly in your browser.

Why we built a free SEO self-audit tool

Most SEO work does not start with a massive audit.

It starts with a page.

You want to know whether the title is right, whether the headings make sense, whether important technical elements are missing, and whether the page has enough information for search engines and AI systems to understand it.

That is where a quick self-audit is useful.

Traditional SEO platforms can give you much more data, but they can also take time to configure and require a paid subscription. They also tend to focus heavily on traditional search.

We wanted a simpler workflow:

Open a page → scan it → see what is wrong → fix the important issues.

The extension also checks GEO and AEO signals, so you can look at whether a page is prepared for AI search and answer engines.

What does the MarkoMetrics extension check?

The extension checks four areas.

1. On-page SEO

The on-page audit checks common elements that affect how a page is understood by search engines, including:

Title tag
Meta description
H1 and heading structure
Image alt text
Canonical URL
Internal links
URL structure

Instead of manually checking these elements one by one, you get the findings in one place.

2. Technical SEO

The technical audit checks:

Meta robots
Viewport
HTTPS
Structured data, including JSON-LD and microdata
Render-blocking scripts
robots.txt
XML sitemap
Broken internal links

The extension can read the site's publicly available robots.txt and sitemap.xml files to perform these checks.

3. Content

The content section looks at:

Word count
Readability
Keyword density
Content freshness

These checks can help identify pages that are too thin, difficult to read, overly focused on a keyword, or simply outdated.

4. GEO and AEO

This is the part that is often missing from traditional SEO checklists.

GEO, or Generative Engine Optimization, and AEO, or Answer Engine Optimization, focus on making content easier for AI search and answer engines to read, understand, and potentially cite.

The extension checks for signals such as:

FAQ schema
Question-format headings
Direct-answer paragraphs
llms.txt
AI crawler access
E-E-A-T signals

If a competitor keeps appearing in AI-generated answers while your page does not, these checks give you another set of things to investigate.

How AI fixes work

Finding an SEO problem is useful. Getting the actual fix written is better.

For supported findings, the extension can generate things such as:

Rewritten title tags
Meta descriptions
FAQ schema
Direct-answer paragraphs
Other content fixes

The AI features use your own API key.

You can connect an API key from OpenAI, Anthropic, or Google Gemini in the extension settings. When you generate a fix, the request goes directly from your browser to the provider you selected.

MarkoMetrics does not add a markup to your AI usage.

This is a bring-your-own-key setup. You use your own provider account and pay that provider for the API usage.

What happens to your data?

The extension does not send your scans through a MarkoMetrics backend.

Your API key and scan results are stored locally in your browser.

When you run a scan, the page is analyzed in your browser. Page content is only sent outside your device when you click Generate fix. In that case, the relevant text is sent directly to the AI provider configured in your extension.

The extension does not use a MarkoMetrics server as a middleman for those requests.

The privacy promise inside the extension is straightforward:

Stored only on this device. Sent directly to the provider when you generate a fix, never to MarkoMetrics.

How to install the MarkoMetrics extension

Install the free MarkoMetrics SEO Extension → tinyurl.com/seo-plugin

After installing:

Click Add to Chrome.
Confirm the installation.
Pin the MarkoMetrics icon to your browser toolbar.

The extension works with Chrome and other Chromium-based browsers, including Edge, Brave, and Arc.

How to run your first SEO audit

You can audit a page in a few clicks.

Open the page you want to check.
Click the MarkoMetrics extension icon.
Click Scan.
Review the overall score and the four category scores.
Open a category to see its findings.
Fix the issues manually, or add your own AI provider key and use Generate fix on supported findings.

Findings are grouped by severity, including critical, warning, and info.

Checks that already pass are collapsed into a count, so the issues that need work stay visible.

How to read the audit results

Do not focus only on the overall score.

The overall score is calculated from the four categories, which means a page can perform well on traditional SEO checks and still have weaknesses in its AI-search readiness.

Look at the individual category scores and then open the findings.

The findings are meant to be specific. Instead of simply telling you to "improve your meta description," the extension shows the current value, explains the issue, and gives you a recommendation.

You can also export the audit as a PDF or JSON.

The PDF is useful when you need to share an audit with a client or teammate. The JSON export contains the findings, fix types, and raw page data, making it useful for handing audit data to another tool or AI agent.

Who is the extension for?

The extension is useful if you regularly work on websites and need quick page-level checks.

In-house marketers can use it before publishing landing pages or blog posts.

SEO freelancers and consultants can run a quick audit before discussing a page with a client.

Founders and small teams can use it when they do not have a dedicated SEO specialist.

SEO teams working on AI visibility can use the GEO and AEO checks to find gaps that traditional page audits may not cover.

Is the MarkoMetrics SEO extension free?

Yes.

The single-page scan is free and unlimited. There is no account requirement and no scan limit.

AI-generated fixes are also available through the extension without a MarkoMetrics subscription. You provide your own OpenAI, Anthropic, or Google Gemini API key, and your provider charges you for the API usage.

Future paid features may include saved audit history, multi-domain tracking, and team features. The free scanning functionality is not being turned into a trial.

Frequently asked questions

Is the MarkoMetrics extension really free?

Yes. Page scanning is free and unlimited, with no account required.

If you generate AI fixes, your selected AI provider may charge you for its API usage. MarkoMetrics does not add a markup.

Do I need an account?

No. Install the extension and scan a page.

What is a GEO or AEO audit?

It checks signals related to how well a page can be read, understood, and potentially cited by AI search and answer engines.

The extension checks things such as FAQ schema, question-based headings, direct-answer paragraphs, llms.txt, AI crawler access, and E-E-A-T signals.

Which AI providers are supported?

The extension supports:

OpenAI
Anthropic
Google Gemini

You provide your own API key for the provider you want to use.

Can MarkoMetrics see my API key?

No.

Your key and scan results are stored locally in your browser. When you generate a fix, the request goes directly to your selected AI provider over HTTPS.

How much does an AI-generated fix cost?

Your AI provider determines the API cost.

For small fixes, the cost is typically a fraction of a cent, depending on the provider and request.

Which browsers are supported?

The extension works in Chrome and Chromium-based browsers such as Edge, Brave, and Arc.

Try the free SEO self-audit

Install the MarkoMetrics SEO Extension → tinyurl.com/seo-plugin

Run it on a landing page, blog post, product page, or another page you want to improve.

You will get the audit first. If you want AI to help write the fixes, connect your own API key and generate them directly from the findings.

If you need help beyond a single-page audit, MarkoMetrics also works on technical SEO, content strategy, GEO/AEO, and growth marketing.

--
Explore MarkoMetrics Marketing Service

How We Automated Google Business Profile Data Audits Across Major B2B SaaS Markets

MarkoMetrics — Mon, 14 Sep 2026 09:32:23 +0000

If you manage local or multi-location SEO for a B2B SaaS company operating across several markets, you already know the pain: Google Business Profiles (GBP) drift out of sync fast. Categories get changed by well-meaning support staff, NAP (name/address/phone) data goes stale after office moves, hours don't get updated for holidays in different regions, and nobody notices until rankings quietly slip.

At MarkoMetrics we manage GBP listings across multiple markets (UK, Singapore, Malaysia, Indonesia, Philippines) for SaaS clients expanding into Southeast Asia. Manually checking each profile every week doesn't scale. So we built a lightweight audit script using the Google Business Profile API to flag inconsistencies automatically.

Here's how it works, and the code so you can adapt it for your own stack.

The problem with manual GBP audits
Data drift: fields get edited by multiple team members with no single source of truth
Category mismatches: businesses often end up with an overly generic primary category, which hurts relevance
NAP inconsistency: address formatting differs across markets (postal code placement, unit numbering conventions)
Silent errors: a wrong phone number or closed status can sit unnoticed for weeks

None of these are catastrophic individually, but together they erode local ranking signals and trust — and B2B SaaS companies with multiple regional entities (or one HQ profile per country) accumulate this drift fast.

What the script checks

We built a Python script that pulls each profile via the API and flags:

Primary/secondary category mismatches against a defined "expected categories" list
Missing or malformed phone numbers per market (using phonenumbers for country-specific validation)
Address field completeness and consistency against a canonical CRM record
Business hours gaps or overlaps
Whether the profile is verified and not suspended
Setup

You'll need:

A Google Cloud project with the Business Profile API enabled
OAuth2 credentials for an account with access to your Business Profile locations
google-api-python-client, phonenumbers, and pandas

pip install google-api-python-client google-auth-oauthlib phonenumbers pandas

The audit script

import pandas as pd
import phonenumbers
from googleapiclient.discovery import build
from google.oauth2.credentials import Credentials

# Canonical data — your source of truth (e.g. pulled from a CRM export)
CANONICAL = {
    "location_id_1": {
        "expected_category": "Software Company",
        "country_code": "SG",
        "expected_phone": "+65 1234 5678",
    },
    # ... add per-location records
}

def get_service(creds_path):
    creds = Credentials.from_authorized_user_file(creds_path)
    return build("mybusinessbusinessinformation", "v1", credentials=creds)

def audit_location(service, account_id, location_id, canonical):
    location = service.accounts().locations().get(
        name=f"accounts/{account_id}/locations/{location_id}",
        readMask="categories,phoneNumbers,storefrontAddress,regularHours,openInfo"
    ).execute()

    issues = []

    # Category check
    primary_category = location.get("categories", {}).get("primaryCategory", {}).get("displayName")
    if primary_category != canonical["expected_category"]:
        issues.append(f"Category mismatch: got '{primary_category}', expected '{canonical['expected_category']}'")

    # Phone validation
    phone = location.get("phoneNumbers", {}).get("primaryPhone")
    if phone:
        try:
            parsed = phonenumbers.parse(phone, canonical["country_code"])
            if not phonenumbers.is_valid_number(parsed):
                issues.append(f"Invalid phone format: {phone}")
        except phonenumbers.NumberParseException:
            issues.append(f"Unparseable phone number: {phone}")
    else:
        issues.append("Missing phone number")

    # Verification / open status
    open_info = location.get("openInfo", {})
    if open_info.get("status") != "OPEN":
        issues.append(f"Location status is '{open_info.get('status')}', not OPEN")

    # Hours check — flag empty hours as a gap
    if not location.get("regularHours"):
        issues.append("No business hours set")

    return {
        "location_id": location_id,
        "issue_count": len(issues),
        "issues": "; ".join(issues) if issues else "OK",
    }

def run_audit(service, account_id, canonical_map):
    results = [
        audit_location(service, account_id, loc_id, data)
        for loc_id, data in canonical_map.items()
    ]
    return pd.DataFrame(results)

if __name__ == "__main__":
    service = get_service("credentials.json")
    df = run_audit(service, account_id="YOUR_ACCOUNT_ID", canonical_map=CANONICAL)
    df.to_csv("gbp_audit_results.csv", index=False)
    print(df[df["issue_count"] > 0])

Run this weekly (cron, GitHub Actions, whatever fits your stack) and pipe the CSV into Slack or email so the team sees drift before it becomes a ranking problem.

Results from running this across our client base

Since automating this, we catch category and phone-format issues within a week of them occurring instead of during a quarterly manual review — which, across a multi-market SaaS footprint, used to mean weeks of degraded local visibility going unnoticed in at least one market at any given time.

Extending it further

A few directions worth taking this:

Add a diff-tracking layer (store daily snapshots, alert only on changes rather than re-flagging static issues)
Extend CANONICAL to pull dynamically from a CRM API instead of a hardcoded dict
Add review-response latency tracking using the Reviews API — slow review responses are also a local ranking factor

If you're running local SEO for a multi-market company and want to compare notes on GBP automation, happy to chat in the comments. We write more about local SEO/GBP work over at the MarkoMetrics blog.