Skip to main content

URL Verifier

Plans: Growth · Pro · Agency (rollout — currently limited to superadmins and invited tenants)

The URL Verifier checks Clione's enriched signals against the live HTML at any URL. Use it when:

  • You want to verify a specific page without opening the entity in Clione.
  • You're QA'ing a freshly launched campaign and need to spot-check a handful of URLs.
  • You're investigating a discrepancy reported by a customer or by an SEO audit tool.
  • A URL is failing in the per-entity Verification view and you want to bypass entity lookup and check the raw page directly.

Open it from the sidebar → URL Verifier. (Currently available to superadmins and team members during the rollout — broader plan availability coming.)

What you can check​

ModeInputOutput
By entity type + storePick entity types (products / categories / collections / pages) + the stores to include. The verifier walks the catalog and runs against every matching entity.Aggregate score across the chosen scope + a sortable table.
Manual URLsPaste a list of URLs, one per line.Per-URL grade + signal-level breakdown.

The page has tabs for both modes. You can run them sequentially without losing previous results.

What each URL is checked for​

Same signals as the per-entity Verification view:

  • Meta title
  • Meta description
  • Canonical URL
  • JSON-LD presence + @type + content match
  • OG tags (og:title, og:description, og:image)
  • BC-only: meta_keywords, search_keywords

The verifier also detects the platform (BC vs Shopify vs Other) from the page markers, so cross-platform stores get the right per-signal rules applied.

Per-platform notes​

BigCommerce​

  • Same preview-code support as the per-entity verifier — paste it in the URL if your store is password-protected.
  • The verifier fetches the storefront URL of each entity. The storefront URL is resolved from the platform's custom_url field, falling back to the entity's name slug if custom_url is empty.

Shopify​

  • The verifier fetches https://<your-shop>.myshopify.com/products/<handle> by default.
  • If you've configured a custom domain in Store → Settings → Storefront URL, the verifier uses that instead. This matters because some themes render different meta tags on the two domains, and you want to verify the canonical one.

Cross-platform / external URLs​

You can paste any URL — even competitor URLs. The verifier still runs the same signal checks, but obviously the DB-vs-storefront diff doesn't apply (Clione doesn't have a DB record for someone else's product). The verifier still grades signal presence + completeness, so this is useful as a quick "how is my competitor's schema?" tool.

Reading the results table​

Each row shows:

  • URL — the page checked.
  • Score — A / B / C / D / F based on signal completeness + match accuracy.
  • Platform — detected platform.
  • Per-signal mini-badges — quick view of which signals passed or failed.

Click the row to open the detail modal, same as the per-entity Verification view.

Filters​

  • Entity types — products, categories, collections, pages.
  • Score — show only A, only Fail, etc.
  • Stores — which stores to include (multi-store tenants).

Filters apply to the catalog-mode results. Manual URL results have a simpler filter (score band only).

How the verifier fetches a URL​

The fetcher uses a headless GET with a stable user-agent string Clione-URLVerifier/1.0 (+https://clione.ai). It does not execute JavaScript by default — what you see is what server-rendered HTML looks like to a typical crawler. If your storefront only renders critical content after JS, the verifier will flag that as missing, which is exactly what an LLM crawler would also see.

For BigCommerce Stencil stores (where the Clione Schema Injector script runs client-side), the verifier still walks the page text for the JSON-LD comment marker Clione injects pre-script. This way the verifier knows the script is present even if it hasn't executed.

For Shopify stores, the verifier looks for the <!-- clione:jsonld --> HTML comment that the Theme App Extension emits before the JSON-LD <script> tag. If the comment is present but the script is empty, the extension is enabled but the metafield is missing — usually a propagation issue.

Timeouts and retries​

  • Per-URL timeout: 10 seconds.
  • Retries: 1 retry with exponential backoff (1 sec, then 3 sec) on 5xx or network errors.
  • 4xx errors are returned as-is — no retry. A 404 means the URL doesn't exist on the storefront.

Rate limits​

  • 100 URLs per minute in manual mode.
  • 1000 URLs per catalog walk (cap is per store, per day) to protect both your storefront and the verifier infrastructure.

If you need to verify more, run multiple smaller batches over the day or contact support to lift the cap.

Export​

The results table has an Export CSV button. The CSV includes:

  • URL
  • Score
  • Platform
  • Per-signal pass/fail (one column per signal)
  • HTTP status
  • Fetched-at timestamp
  • Error message (if any)

Use this for audit trails or to feed into your own dashboard.

Troubleshooting​

All URLs fail with "Storefront unreachable" — DNS or firewall. Try one of the URLs in incognito; if it loads, ping us with the URL so we can diagnose. If your storefront is behind Cloudflare with the WAF set to challenge unknown user agents, allowlist the Clione-URLVerifier/1.0 user-agent.

One URL fails with "Storefront unreachable" but loads in browser — Often a Cloudflare bot-protection rule. Open Cloudflare → Security → Bot Fight Mode → allow our user-agent. Or pass a preview code if it's BC sandbox.

JSON-LD reported as missing on a page that has it — Some themes render JSON-LD after the DOMContentLoaded event via JS. The verifier fetches the raw HTML, so it only sees server-rendered JSON-LD. For BC, this is by design (the Schema Injector runs JS). For Shopify, JSON-LD is server-rendered by the theme app block, so if it's missing, the block is not enabled — see Schema Injector.

Verifier reports score F but live page looks fine to me — The most common cause is a noindex meta robots tag or a missing canonical URL. Click the row → Detail modal → look at the Failed signals list. Each failure links back to which signal and the actual HTML the verifier saw.

BigCommerce storefront returns 200 OK but verifier says 404 — BC Stencil sometimes returns 200 with a soft-404 (the "page not found" template). The verifier treats a 200 with no Product schema or no Article schema as a likely soft-404 and flags it. Use the BC admin to confirm the entity is published and visible.

Shopify password page interferes — If your shop is in development mode with a password, the password page redirects every URL. Add the password as a query string parameter on the URL Verifier input: https://shop.myshopify.com/products/foo?password=YOUR_PASSWORD.

Comparison vs per-entity Verification​

Verification (per entity)URL Verifier
InputClione DB entity IDAny URL
Knows what it should beYes (DB record)No (treats URL as a black box)
Cross-platformSingle platform per entityAny platform
Competitor URLsNoYes
Trend over timeYes (per-entity history)No (each scan is point-in-time)
Where to find itPer-entity Verification tab + Verification pageSidebar → URL Verifier
Auto-runsYes (after every propagation)No (manual)

Use the per-entity Verification for your own catalog. Use the URL Verifier for ad-hoc checks (your own URLs not yet in Clione, competitor URLs, partner URLs).

Sharing results​

The URL Verifier doesn't have a native share feature today — each session's results are local to your dashboard. Workaround:

  • Export the CSV and share the file.
  • Add the URL to a Pulse scan (via the Chrome extension) — Pulse scans have public Site URLs you can share. Caveat: Pulse uses different scoring weights from the URL Verifier.

Shareable URL Verifier results are on the roadmap.

Use cases worth knowing​

  • Competitor spot-check — paste 5 of your top competitor's product URLs. The grade tells you how well-positioned they are for AI crawlers. If they're scoring A+ across the board, treat them as a benchmark; if they're failing, you have an opportunity to leapfrog them.
  • Pre-launch QA — before a Black Friday landing-page push, paste the URLs of the new collection pages. Catch missing meta descriptions or broken canonical tags before traffic hits.
  • Post-deploy regression — after a theme update, paste 10 URLs across your catalog. Confirm nothing regressed.
  • SEO consultant handover — export the CSV and hand to your consultant for an audit baseline.
  • Disputed verification result — when the per-entity verification flags a Fail and you swear the page is correct, drop the URL into the URL Verifier. It performs the same checks but doesn't rely on the Clione DB record, so you can confirm whether the issue is real.

Headless-storefront caveats​

If your storefront is headless (Hydrogen, Catalyst, Next.js SSR), the verifier scans the rendered HTML response. Caveats:

  • CSR-only headless — pages that render meta + JSON-LD only after JS execution will score low. Pulse fetches HTML only.
  • Edge runtime — pages served from edge functions (Cloudflare Workers, Vercel Edge) may return different markup for the verifier's datacenter IP than for normal traffic. If you suspect this, confirm by hitting your URL from a server-side curl and comparing.
  • Authentication walls — if your storefront requires login (e.g. B2B with a wholesale gate), the verifier can't get past it. Use a temporary public route or pass a session cookie via the Advanced → Request headers field in the URL Verifier.

Batch input formats​

The Manual URLs tab accepts:

  • One URL per line.
  • Comma-separated values on a single line.
  • Tab-separated.
  • A sitemap.xml URL — paste the sitemap URL on its own line and the verifier walks the sitemap, extracting URLs to verify (capped at the rate limits above).

If you have a CSV from a tool like Screaming Frog, copy the URL column and paste — the verifier ignores leading/trailing whitespace and any header line.

Comparing two runs​

After running two scans (e.g. before and after a theme update), select both in the results table and click Compare. The compare view shows a side-by-side per-signal diff per URL with green for improvements and red for regressions.

The compare view is read-only and not exportable today — copy/paste or screenshot if you need a record.

Per-signal weight reference​

For transparency, the per-signal weights in the URL Verifier grading:

SignalWeightNotes
Title present + 30-65 chars15Title is the most clickable surface — heaviest weight.
Meta description present + 100-180 chars15Second most clickable.
Canonical URL present + matches expected10Avoids duplicate-content penalties.
JSON-LD present20The biggest single AI-readiness factor.
JSON-LD @type matches entity type10A page with @type=WebPage instead of @type=Product scores worse than no JSON-LD at all.
OG og:title, og:description, og:image10LinkedIn / WhatsApp / iMessage previews.
og:url matches canonical5Detects cross-canonicalization bugs.
BC-only: meta_keywords5BC's native search uses this; harmless on other platforms.
BC-only: search_keywords5Same.
Robots not blocking5If the page is noindex, the rest is moot.

100 total. The grade comes from the sum, mapped to A/B/C/D/F.