Open Graph Preview & Metadata Audit

Global tools

This tool never fetches or crawls a URL and it is not a live preview: the reading is local. In your browser, open the page you want to audit, press `Ctrl+U` (View Source) and copy the `<head>` - or the whole document if you also want the body checks - then paste it below. The tool reads what a machine reads: the title and description a search result would use, the Open Graph and Twitter tags a shared link would use, the canonical, the robots meta, the structured data - and then twenty checks that say what is missing, what is written twice, and what disagrees with what. The same page builds a `sitemap.xml` from a list of addresses, and a `robots.txt` from three choices, with every line of both explained.

Three jobs that share one subject: what a machine reads from a site. Each mode shows only the fields it uses.

In a browser: open the page, press Ctrl+U for the source, select all of it and paste. The whole document or just the head both work; a body adds the heading and image checks.

Optional. It is shown in the search-result preview when the page has no canonical of its own.

Read only by the middle policy. A whole address pasted here is reduced to its path; a path without a leading slash gets one.

Leave it blank for the name the file usually has: "sitemap.xml", "robots.txt", "head-audit.txt".

Results update as you type. Nothing leaves your device.

Read the way a crawler reads it

nothing to fix

18 of 20 checks pass and 2 are worth a look. The share card is built from Open Graph.

Title
57 characters
Description
146 characters
Checks passing
18 of 20
Share card
Open Graph
Nothing here would stop a page from being found. What is left is the difference between a result that is useful in a list and one that is merely present.

The search result, and the card

The search result, as a crawler would build it:

Mortgage Calculator - Monthly Payment, No Signup | danfio
https://danfio.com/tools/mortgage-calculator/
Work out a monthly payment, the total interest over the life of the loan, and what one
extra payment a month does. Free, no signup, formula shown.

The character counts are exact: 57 for the title, 146 for the description.
The guidance usually quoted is 60 and 155; a real result box is cut by pixel
width, so the letters matter as much as the count.

------------------------------------------------------------

Built from Open Graph:

title        Mortgage Calculator - danfio
description  Monthly payment, total interest, and what one extra payment does.
image        https://danfio.com/og/mortgage.png
site name    danfio
address      https://danfio.com/tools/mortgage-calculator/
type         website

Every check, and what it says

CheckResultWhat it says
One titleok“Mortgage Calculator - Monthly Payment, No Signup | danfio”
Title lengthok57 characters, inside the 60 usually quoted.
One meta descriptionok146 characters.
Description lengthok146 characters, inside the 155 usually quoted.
A canonical linkokhttps://danfio.com/tools/mortgage-calculator/
Canonical against robotsokNo contradiction.
RobotsokNo `robots` meta, which means index and follow.
A viewport tagokwidth=device-width, initial-scale=1
A character setokutf-8
A language on <html>oken
A faviconok/favicon.svg
Open Graph tagsok`og:title`, `og:description` and `og:image` are all present.
The image addressokhttps://danfio.com/og/mortgage.png
The image shapelookNo `og:image:width` and `og:image:height`, so the shape cannot be checked from the page alone. This tool does not fetch the picture: declaring the two numbers is what lets a crawler lay a card out before the image has finished downloading.
The shared addressokhttps://danfio.com/tools/mortgage-calculator/
A Twitter/X cardok`twitter:card` is `summary_large_image`, with no image of its own, so the card borrows the Open Graph one.
Tags written twiceokEvery meta tag is written once.
Structured dataokNo JSON-LD. That is allowed: it decides whether a result can carry stars, a price or a recipe, not whether it appears.
A first-level headingokExactly one.
Alt textlook1 of 1 images have no `alt`, so a screen reader announces them as “image” and a search engine has no idea what they show.

The order is the order a person would fix them in: the tags a page cannot ship without come first.

What this reading cannot tell you

  • A result box is cut by pixel width rather than by characters: sixty `i`s and sixty `W`s are different widths. The counts here are exact, and the cut marks sit at the 60 and 155 characters usually quoted, which is a guidance rather than a limit.
  • No page was fetched, so nothing here is the picture, and nothing here is necessarily what the server sends: an edge worker, an email-obfuscating proxy or a client-side renderer can all rewrite the tags between the source and the crawler.
  • A crawler that runs JavaScript sees a different document from one that does not. What was pasted is read as text, which is exactly what a crawler without JavaScript receives.
  • None of these tags is a ranking factor on its own: they decide how a result looks once it is in a list, not whether it gets there.

Because nothing is fetched, a private page pasted here goes nowhere: the audit runs entirely in your browser and nothing is uploaded. That is also why the tool can say plainly what it cannot know - the picture itself, what a hosting service or a site builder rewrites on the way out, and what a crawler that runs JavaScript would see - and why it is a local checklist rather than a claim about how a page will really render.

About this open graph preview & sitemap

Ever pasted a link into a chat and watched the preview come out blank? That is usually a missing or malformed Open Graph tag, and this page reads a page the way a crawler does: title, description, canonical, the Open Graph and Twitter cards, JSON-LD, headings and image alt text, as a twenty-item checklist.

The reading is done client-side, from the HTML you paste or a URL the tab fetches, and the twenty checks are grouped by repair order: the three failures a page cannot ship without, then the cards, then the body. It also builds a `sitemap.xml` and a `robots.txt` from a list of addresses and explains each line it writes.

None of these tags is a ranking factor on its own; they decide how a result looks once it is in a list, not whether it gets there. The title width is reported as an exact character count rather than an invented pixel estimate. Check what you actually pasted before trusting a green checklist.

How this open graph preview & sitemap works

Reading a page the way a crawler reads it

A search result is built from three fields: the `<title>`, the `<meta name="description">` and the address. A shared link is built from a fourth set: Open Graph (`og:title`, `og:description`, `og:image`, `og:url`, `og:site_name`) for most platforms, and `twitter:*` for X, which also falls back to the `og:` tags by name. This page reads all of them, then shows the two previews side by side with the fallbacks applied, so a page with only `twitter:*` is shown as a page with only `twitter:*` rather than as a page with a card.

The reading is a scan of the text rather than a parse of a live document, which is deliberate: it is what a crawler without JavaScript receives, and it is why a `<meta>` written inside a comment or inside a `<script>` is correctly ignored. The tag reader is the one the minifier uses, so a `>` inside a quoted attribute value does not end a tag here either.

A page with nothing to say about a field is not given a default: the checks report it as missing, and the preview shows what would actually be shown - which for a page with no `og:image` is a grey box, and for a page with no description is a sentence a search engine picked out of the body.

Twenty checks, and why they are a checklist rather than a score

Three of them are failures rather than warnings, because a page cannot really ship without them: a title, a description, and a canonical - plus Open Graph tags, without which a shared link is a bare address. The rest are warnings: a title that is longer than the widely quoted 60 characters, a description shorter than 70, a viewport that does not set `width=device-width`, a missing `<html lang>`, no favicon, an `og:image` that is relative (so a crawler cannot fetch it), an `og:image` whose declared shape is not the card’s 1.91 to 1, an `og:url` that disagrees with the canonical, no `twitter:card`, a tag written twice, JSON-LD that does not parse, no `<h1>` or more than one, and images without `alt`.

The one number this page refuses to invent is the pixel width of a title. Google truncates a result by pixel width, and how many characters fit depends on the letters: sixty `i`s and sixty `W`s are not the same width. So the counts here are exact character counts, the cut marks sit where the guidance is usually quoted, and the page says which of the two it is doing.

The ordering is the ordering of repairs: a title, a description and a canonical first, the cards after them, and the body checks last if a whole page was pasted rather than only a head. A page that passes all twenty is not thereby ranked: not one of these tags is a ranking factor on its own. They decide how a result looks once it is in a list, not whether it gets there.

sitemap.xml: what belongs in one, and what a crawler does with it

A `<loc>` must be an absolute address, and the builder refuses anything else by name and line number rather than writing a file with a relative path in it and hoping. What may follow an address is `<lastmod>`, `<changefreq>` and `<priority>`, in that order, and the page writes them in the order the schema lists them. A URL that is written twice is dropped the second time and reported; characters a sitemap cannot carry literally - non-ASCII, and spaces - are percent-encoded, and the report says which addresses were changed, because `%C3%A9` is a change a reader should know about.

Two limits are real and are checked: 50,000 URLs and 50 MB uncompressed in one file. Beyond that a crawler reads part of the file and stops, so the report says so and suggests a sitemap index. The extras are worth exactly what they are worth, and the page says which: `lastmod` is believed when it is accurate, and a date of “today” on every URL teaches a crawler to ignore the field; `changefreq` and `priority` are ignored by Google entirely. A sitemap does not get a page crawled - a link from a page that is already crawled does that. It says the address exists.

robots.txt: the two lines that look the same and mean the opposite

`Disallow:` with nothing after it allows everything. `Disallow: /` blocks everything. Both look like rules, both are one line, and the second one has taken real sites out of search. The builder and the explanation on the page come from the same list of lines, so the table cannot describe something the file does not say, and the meaning of each line is printed beside it: which paths are blocked, what a `/` would do if it were in that list, and why the `Sitemap:` line is there at all.

The file is a request rather than access control, and it is public: a path listed in it is a path a scraper now knows about. It also works per host, so a subdomain needs its own file, and so does the same site served over both `http` and `https`. `Crawl-Delay` is offered because the directive exists and some crawlers read it, with the honest note that Google ignores it and that a real rate limit belongs in the crawler’s own console.

Worked examples

Each example below was run through the calculator on this page when the site was built, so the numbers match what you see when you enter the same inputs.

The sample page, read as a crawler reads it

Read the way a crawler reads it

nothing to fix

18 of 20 checks pass and 2 are worth a look. The share card is built from Open Graph.

Title: 57 characters · Description: 146 characters · Checks passing: 18 of 20 · Share card: Open Graph

The sample head has eighteen checks passing and two worth a look: one image with an empty `alt`, and an `og:image` whose height was never declared - so the shape cannot be checked from the page alone.

A page with no Open Graph tags at all

Paste the page source: <html lang="en"><head><title>A page</title><meta name="description" content="A description that is long enough to be useful in a search result, and no longer than the guidance either."></head><body><h1>A page</h1></body></html>

Read the way a crawler reads it

2 to fix

9 of 19 checks pass and 8 are worth a look, with 2 that a page cannot really ship without. The share card is built from nothing but the title and the description.

Title: 6 characters · Description: 106 characters · Checks passing: 9 of 19 · Share card: nothing but the title and the description

The card check fails: without one `og:` tag, a shared link is a bare address, and every platform guesses what to put beside it.

A canonical and a noindex that disagree

Paste the page source: <head><link rel="canonical" href="https://example.com/"><meta name="robots" content="noindex, follow"></head>

Read the way a crawler reads it

4 to fix

4 of 18 checks pass and 10 are worth a look, with 4 that a page cannot really ship without. The share card is built from nothing but the title and the description.

Title: 0 characters · Description: 0 characters · Checks passing: 4 of 18 · Share card: nothing but the title and the description

One says this page is the address that counts; the other says leave it out of the index. The pair is reported as the failure it is rather than as two passing checks.

The sample address list, built into a sitemap

What to do: Build a sitemap.xml from a list of addresses

Sitemap

4 URLs

Built from 4 usable lines. The file is 620 B, well inside the limit for one file.

URLs written: 4 · Lines refused: 0 · Written twice: 0 · Percent-encoded: 0

Four URLs, three of which carry their own date, changefreq and priority: the ones that do not take whatever the defaults say. The file is under a kilobyte.

A list with a line that cannot be used

What to do: Build a sitemap.xml from a list of addresses · Addresses, one per line: /about/ https://example.com/ https://example.com/ 2026-02-30

Sitemap

1 URL

Built from 1 usable line, with 1 refused and 1 written twice. The file is 163 B, well inside the limit for one file.

URLs written: 1 · Lines refused: 1 · Written twice: 1 · Percent-encoded: 0

The relative line is refused with its number, and the date that is not on the calendar is dropped with a note - the URL itself is still written, because the address was fine.

A robots.txt that blocks two folders

What to do: Build a robots.txt · What crawlers may do: Block the paths I list

robots.txt

0 paths

Every address whose path begins with one of the lines below is blocked.

Crawlers covered: every one · Blocked: 0 paths · Sitemap line: yes · Crawl-Delay: none

Every line is explained: what `Disallow: /admin/` blocks, why the `Sitemap:` line is not about permission, and that a blank `Disallow:` would have meant the opposite of what it looks like.

Frequently asked questions

Is the page I paste uploaded anywhere?

No. The source is read by a fixed rule running in your browser tab, there is no endpoint behind the page, and the only request it makes is for the page itself. That is what makes it reasonable to paste a staging page, a customer-facing page or a page behind a soft launch here. The static copy of this page was computed when the page was prepared from a sample document, so a visitor with JavaScript switched off still sees a real reading rather than an empty box.

Why not give it a URL and let it fetch the page?

Because that would need a server, and a server is the one thing this site does not have: every tool here runs in the browser. It is a real limit, and it is stated rather than hidden - paste the source with Ctrl+U, or paste just the `<head>` part if that is all you want checked. There is a second advantage to pasting rather than fetching: what you paste is what a crawler without JavaScript receives, which is often not the same thing as what your browser renders.

How accurate is the search-result preview?

The text is accurate and the truncation is a guidance. What this page shows is your title, your address and your description laid out the way a result is laid out, with the cut marks at 60 and 155 characters, which are the numbers usually quoted. Google truncates by pixel width instead, and Arial 20px fits more `i`s than `W`s, so a 65-character title of narrow letters can survive while a 55-character title of wide ones is cut. Because that depends on the letters rather than on the count, this page reports the counts exactly and refuses to print a pixel number it would be guessing at.

Should I add changefreq and priority to my sitemap?

They are optional and Google ignores both, so the honest answer is that they cost nothing and buy nothing there. `lastmod` is the one worth getting right: it is used when it is accurate, and a sitemap where every URL says “today” teaches a crawler to distrust the field, which is worse than leaving it out. The page offers all three because the protocol has them and some other crawlers read them; it says which is which rather than implying they all count equally.

Can a robots.txt remove a page from Google?

It can stop a well-behaved crawler from fetching it, which usually keeps it out of the index over time - but `Disallow` is not the same as `noindex`, and using both together is a classic trap: a crawler that is not allowed to fetch a page cannot see the `noindex` inside it either, so the page can stay in the index with no description. To remove a page, use `noindex` and let it be crawled, or use the search engine’s own removal tool. This page prints what each line of the file does, for exactly that reason.

Does the tool check my Open Graph image?

It checks everything that can be known from the text: that the address is absolute, so a crawler can fetch it, and that any declared `og:image:width` and `og:image:height` match the card’s roughly 1.91 to 1 shape. It also says plainly that it did not download the picture, because it has no server to download it with. A file that is a 404, a 5 MB photograph, or a PNG with transparency that will be rendered on white all look identical to this reading and different to a person seeing the card.

My site is a single-page app. Does this tell me anything useful?

It tells you what a crawler that does not run JavaScript sees, which is the harder half of the problem - and worth knowing, because the crawlers that build share cards do not run JavaScript at all. If the tags are added by the site’s scripts after the page loads, paste the rendered source (the inspector’s “copy outerHTML” rather than Ctrl+U), and remember that a social crawler sees the version without them. The honest fix is server-rendered or pre-rendered tags.

Assumptions and sources

  • The page reads the Open Graph protocol, Twitter Card tags, canonical links and JSON-LD, and writes sitemaps to the sitemap.org rules.
  • The checks are a fixed checklist: title, description and canonical are failures, the rest are warnings such as `noindex` beside a canonical.
  • No page is fetched and no image is downloaded; pasted markup stays in your browser and is never uploaded.

Last reviewed 2026-09-17. Runs locally on your device; keep backups; no financial advice applies. Read the full disclaimer.

Where a figure on this page comes from an official agency — HUD, IRS, FICO or a state body — the site keeps a dated snapshot of the source page in its sources library, and a scheduled job re-checks that snapshot, so the number can be traced back to the document it came from.