Get a new page ready for search engines
You built the page and it works. These twelve tools are the checklist between that and shipping it — writing the metadata, making it crawlable, verifying how it previews when shared, and checking the speed and readability that actually move rankings. Everything that can run in your browser does.
The short answer
To get a new page ready for search engines: write its title, description and social meta tags first, then make sure crawlers can reach and index it — a clean URL slug, a canonical URL, a correct robots.txt and a sitemap entry. Verify the metadata against how the live page actually previews when shared rather than trusting what you typed, then check the two ranking factors you control directly: how fast the page feels (Core Web Vitals) and how easy it is to read. Most launch problems are a missing tag or a page accidentally blocked from indexing, not the content itself.
Write the metadata
title, description, and social tagsEvery page needs its title, description and social-preview tags written before anything else. Get these wrong and nothing downstream matters — the crawl, the sitemap and the speed budget are all in service of a link nobody clicks.
Make it crawlable
so search engines can find and index itA page search engines can't reach, or are explicitly told not to index, doesn't matter how good its content is. This stage is about the plumbing between your URL and the index.
Verify how it actually shares
before it goes outThe metadata you wrote in stage one either works or it doesn't. Check it against how the page really renders when shared, rather than trusting what you typed into the generator.
Check it's fast and readable
the ranking factors you can controlTwo things affect ranking and experience that have nothing to do with metadata: how fast the page feels, and how easy the content is to read. Both are measurable, and both are on you.
Metadata is the page before the page
Before a search engine renders a single word of your content, it reads the tags in your `<head>`, and before a person clicks a shared link they see a preview card built from those same tags. That preview is the page as far as the click is concerned — the real content only gets a chance if the card earns the click first.
So the metadata is where a launch starts. HTML Meta Tag Generator produces the whole block at once: title, description, keywords, author, canonical URL, robots directive and theme colour, plus the Open Graph and Twitter Card tags that turn a bare link into a rich preview. Copy or download the ready-to-paste HTML and it goes straight into the page.
Making the page findable
A page nobody can crawl is a page nobody ranks. Findability starts with the URL itself: Slug Generator turns the page's title into a clean, URL-safe slug — transliterating accents, stripping special characters and joining words with a dash — so you ship a readable, keyword-relevant path instead of `?p=4471`. Then decide the one canonical form of that URL with URL Canonicalizer: it lowercases the scheme and host, strips default ports, resolves `./..` segments, sorts query parameters, removes tracking params like `utm_*`, `fbclid` and `gclid`, drops fragments and collapses duplicate slashes — the same normalisation a search engine does when it decides whether two URLs are the same page.
With the URL settled, tell crawlers where they can go. Robots.txt Generator writes a spec-correct robots.txt with a default rule group, an optional group for one named bot (Googlebot, GPTBot and the like), a crawl-delay and your sitemap URLs. Then generate the sitemap itself with Sitemap XML Generator, which follows the sitemaps.org spec and takes per-URL lastmod, changefreq and priority through an optional CSV header row.
- 1Assuming robots.txt reads top to bottom
It doesn't. Under RFC 9309, the longest matching rule wins regardless of order, and on a tie Allow beats Disallow. A short `Disallow: /` sitting above a longer `Allow: /blog/` does not block your blog. Robots.txt Tester applies those exact rules against a URL and shows the single line that decided the verdict.
- 2Never testing the file you just wrote
A robots.txt that blocks the very page you're launching is a silent, total failure — the page just quietly never appears. Paste the file and the URL into Robots.txt Tester and confirm the path is Allowed for the crawler you care about before you ship.
Verify, don't trust what you typed
Everything so far was written blind — you typed tags into a generator and pasted them into a template. The point of this stage is to check that what you meant to publish is what actually went out.
Run the live URL through Open Graph Checker to fetch the real page and inspect the Open Graph, Twitter Card and standard meta tags it serves — a missing `og:image` or a description that got templated away shows up here and nowhere in your source. If you want share buttons on the page, Share Links Generator builds ready-to-use links for Facebook, X, LinkedIn, Pinterest, Reddit, WhatsApp, Telegram, Tumblr, Weibo, VKontakte and email — with no share widget or third-party script, which is the point: those widgets are a common source of extra tracking scripts and slower loads.
The ranking factors you actually control
You can't control the algorithm, but you can control two things it cares about. Web Vitals Score Calculator grades your Core Web Vitals — LCP, INP and CLS, plus optional FCP, TTFB and TBT — against Google's own Good / Needs-Improvement / Poor thresholds and gives a per-metric breakdown with targeted fixes. The other is readability: Readability Score Checker scores your copy with six named formulas — Flesch Reading Ease, Flesch-Kincaid Grade Level, Gunning Fog, SMOG, Coleman-Liau and Automated Readability Index — alongside word, sentence and syllable counts.
- Write
- Generate the <head> in HTML Meta Tag Generator, preview the card in Open Graph & Twitter Card Preview
- Crawl
- Slug from Slug Generator, canonical from URL Canonicalizer, add the URL to Sitemap XML Generator, confirm Allowed in Robots.txt Tester
- Verify
- Deploy, then check the live tags with Open Graph Checker and the redirect chain with Redirect Checker
- Tune
- Grade the page in Web Vitals Score Calculator and the copy in Readability Score Checker
Four stages, one page, no step that depends on a tool that isn't in this collection.
- 1Treating one readability score as the truth
The six formulas weigh sentence length and word complexity differently, so two of them can disagree on the same paragraph by design — that's expected, not a bug. Read them as a spread: if all six point the same way, that's a strong signal; if they scatter, look at what your sentences are doing.
Which one do I want?
Several tools here overlap. The short version:
| Open Graph & Twitter Card Preview vs Open Graph Checker | Editing and previewing the card before the page is published. | Fetching the live page to confirm the tags it actually serves. |
|---|---|---|
| HTML Meta Tag Generator vs Open Graph & Twitter Card Preview | Producing the full <head> block — SEO tags plus OG and Twitter. | Focusing on just the social card and seeing how it will look. |
| robots.txt Generator vs robots.txt Tester | Writing a spec-correct robots.txt from rule groups and a sitemap. | Checking whether a specific URL is Allowed or Disallowed, and why. |
| URL Canonicalizer vs Redirect Checker | Deciding the single canonical form a URL should take. | Tracing where a URL actually redirects, hop by hop. |
Why this set
Metadata, crawlability, sharing, speed — the four things that decide whether a new page is ready, arranged as the sequence you'd actually run them in.
The generators and calculators run in your browser. Your draft metadata, copy and URLs stay on your machine — only the live-URL checks fetch a page, and that page is already public.
RFC 9309 robots precedence, the sitemaps.org schema and Google's own Web Vitals thresholds — the tools apply the real rules, not a rough approximation of them.
Questions
What order should I do these steps in?
Write the metadata first — the title, description and social tags — because everything downstream serves a link people have to want to click. Then make the page crawlable: pick a clean slug, settle the canonical URL, write a correct robots.txt and add the page to your sitemap. Once it's deployed, verify the live tags and redirect chain, and finally check the two ranking factors you control directly, page speed and readability.
Why isn't my new page showing up in search even though robots.txt looks fine?
robots.txt doesn't read top to bottom — under RFC 9309 the longest matching rule wins and Allow beats Disallow on a tie, so a broad Disallow above a narrower Allow can still block the page, or a rule you thought was scoped can catch it. Paste your file and the page's URL into the robots.txt tester: it applies the real precedence rules and shows the exact line that decided whether the path is allowed.
What's the difference between previewing and checking Open Graph tags?
Previewing happens before the page is live: you edit a title, description and image and see the resulting social card, which is for getting the tags right while you write them. Checking happens after deploy: the Open Graph checker fetches the real URL and reports the tags actually being served, including any that are missing. You want the preview to design the card and the checker to confirm it shipped.
Do the readability scores need to agree with each other?
No. Flesch Reading Ease, Flesch-Kincaid, Gunning Fog, SMOG, Coleman-Liau and the Automated Readability Index weigh sentence length and word complexity differently, so two of them disagreeing on the same text is expected rather than a mistake. Read them as a spread — six formulas pointing the same direction is a strong signal, and a wide scatter is a cue to look at what your sentences are doing.
Why does an HTTPS→HTTP redirect matter for SEO?
A redirect chain that drops from HTTPS to HTTP partway through both exposes the request in transit and muddies which scheme is canonical, so crawlers can end up unsure whether the secure or insecure URL is the real page — splitting the signals a single page should consolidate. The redirect checker traces every hop and flags insecure downgrades, redirect loops and excessive hop counts so you can catch them before they cost you.