Facebook's graph crawler builds share previews by reading four required Open Graph meta tags — og:title, og:type, og:image and og:url — from the head of your page, so giving the crawler access means both authoring a valid tag block and making sure Facebook's fetch can reach the canonical URL and image. The Open Graph Generator handles the authoring half: it accepts a title, object type, canonical URL and image URL, then emits the four required properties first, followed by optional description, site name and locale, with exact HTML escaping and no platform-specific fields mixed in. The verification half — confirming Facebook's bot can actually fetch your page and image, and re-crawling after edits — is a separate check you run after deployment. Both halves matter: a perfect tag block on a page the crawler cannot reach produces the same blank preview as missing tags on a perfectly reachable page, and neither half is enough on its own.
For most people searching for Facebook Graph API access, the actual goal is a working share preview on Facebook, LinkedIn, Discord, Slack and similar surfaces that consume Open Graph metadata. The full Facebook Graph API used by app developers — with app review, OAuth tokens and the /me, /feed and /oauth endpoints — is a separate concern covered by Meta's developer documentation. This article focuses on the share-preview path: what metadata Facebook's crawler needs, how to produce a clean block of og:* tags, and how to confirm Facebook can actually reach your page. The Open Graph Protocol specification defines the property names and order; the Open Graph Generator applies that specification to a focused form so the output stays auditable.
What "Facebook Graph API Access" Means for Share Previews
Two different systems get called Facebook graph access in practice. The first is Meta's developer Graph API — a programmatic interface for app developers, accessed with app credentials and OAuth tokens, used to read and write user data after Meta's app review. The second is Facebook's share-preview crawler, a fetch bot that follows canonical URLs from shared links and reads Open Graph meta tags out of the page head to render a share card. SEOs, site owners and content publishers searching for this term almost always mean the second one, because that is what determines whether a Facebook share shows the right title, image and description. The Open Graph Generator solves exactly this second case: it produces the tag block that the share-preview crawler consumes, in stable required-first order, without mixing in platform-specific fields that the protocol does not require.
The Four Required Properties Facebook's Crawler Reads
The Open Graph Protocol specification defines four required properties that every shareable object must declare. Facebook's crawler, like other protocol consumers, returns a degraded or empty preview when any of these are missing or malformed. The table below shows the role of each required property and the rules the Open Graph Generator enforces for it.
| Property | Role in the share card | Rules enforced by the generator |
|---|---|---|
| og:title | Headline shown above the preview | Trimmed, length-bounded, rejected on control characters, HTML-escaped for attribute output |
| og:type | Classifies the object | Limited to website or article; runtime-checked again even if the select is altered |
| og:image | Visual rendered inside the preview | Absolute HTTP(S) URL, fragment-free, no embedded credentials |
| og:url | Canonical object identifier | Absolute HTTP(S) URL, fragment-free, no embedded credentials |
Optional properties are emitted only when provided: og:description summarizes the object, og:site_name names the larger site, and og:locale uses a conservative language_TERRITORY shape such as en_US, fr_FR or de_DE that the generator validates. Missing any required value blocks output rather than producing an incomplete preview block — that is deliberate, because partial blocks confuse crawlers more than missing ones do.
Build a Crawler-Ready Open Graph Block
Run these steps in order. Do not skip the source inspection at the end because build tools frequently reorder or overwrite head tags, and a duplicate or malformed meta element will silently degrade the share preview.
- Open the Open Graph Generator and enter the exact object title you want shown in Facebook's preview — not the page's HTML title element, which can differ.
- Choose the object type: website for a home page or section landing, article for a single post or news item.
- Paste the canonical URL of the page into the URL field. It must be absolute, start with http:// or https://, contain no #fragment, and embed no username or password.
- Paste the absolute image URL. Same rules apply: HTTP(S), no fragment, no credentials. The image should live on a host Facebook's crawler can reach.
- Optionally fill og:description with a single-sentence summary, og:site_name with the publication name, and og:locale with a conservative tag like en_US.
- Generate the block and copy the output. Confirm visually that the four required properties appear first, in stable order, with no extra platform-specific tags mixed in.
- Paste the block inside the head of the canonical page, before any framework- or plugin-injected meta tags. Do not place it as visible body text or duplicate it through both a framework and a plugin.
- View the delivered source of the live page and verify each og:* tag is present, unduplicated, and not rewritten by your build tool. The generator's trim, length and HTML-escape rules are applied for you; the source check protects against silent overwrites.
After deployment, you still need to confirm the crawler can reach what you just declared — that is the next section.
Verify Facebook's Crawler Can Reach the Page
Authoring a clean og:* block is necessary but not sufficient. Facebook's share-preview crawler must also be able to fetch the canonical URL you declared in og:url and the image URL you declared in og:image. Open Facebook's Sharing Debugger, paste the canonical URL, and read the response. The debugger will report whether the URL is reachable, which og:* tags it parsed, which image it fetched, and any warnings about size or dimensions. If the response shows "Could not retrieve" or "Provided og:image URL could not be fetched", the issue is at the crawl layer, not in your tag block — typical causes are robots.txt blocking Facebook's crawler user-agent, an authentication wall in front of the page, or an image host that returns a 4xx or 5xx to non-browser clients.
Three concrete checks during verification. First, confirm the canonical URL resolves with HTTP 200 for an unidentified crawler — opening the page in a private browser tab is not enough because authenticated previews can mask the crawl path. Second, load the image URL directly and confirm the response is the expected image bytes, not an HTML error page or a redirect chain that ends in a different image. Third, note any "Inferred Property" warnings from the debugger — these mean Facebook fell back to values it guessed from your HTML, which signals an og:* tag was missing or unreadable even though the page looked fine in your editor.
Why Facebook Still Shows an Outdated or Wrong Preview
Three persistent causes survive even when the tag block is correct and the crawler can reach the page. First, cached previews: Facebook stores the rendered share card against the URL and can keep showing the old version for hours after you edit the og:* tags, so trigger a fresh scrape in the Sharing Debugger after every meaningful change. Second, image handling: each platform applies its own minimum dimensions, maximum byte size and aspect-ratio cropping, and the generator cannot verify those — verify against Facebook's current image specifications before assuming a 200x200 thumbnail will be honored. Third, content mismatch: the og:* block should describe what is actually visible on the page; a misleading title, description or image can disappoint visitors and undermine trust even if it earns a click
If your object needs more than the basics — for example, an article with a publication date, author and section — the Open Graph Protocol defines additional og:article:* properties that fall outside this generator's scope. For richer types like music, video or profile, the protocol requires structured fields the generator does not collect, so use a specialized implementation in those cases. For image-quality issues specifically, the guide on creating an Open Graph image URL that renders correctly walks through the dimensions, encoding and host concerns the generator deliberately does not touch.
For a deeper look, see SERP Snippet Preview API Alternative for Local Editing.