Sharing debugger

Debug and validate metadata HTML markup, including Open Graph, microdata, RDFa, JSON-LD, and more. Preview how your URL appears on major social networks instantly.

How do I debug a broken link preview for any URL?

Paste any URL into this sharing debugger tool to inspect its title, description, image, favicon, canonical URL, locale, and link previews across major platforms. If you need the full extracted data, compare the result with Microlink Metadata.

Compare the detected metadata with the recommended fixes, update your tags, and then re-run the check to verify the preview is correct. For implementation details, review the metadata guide.

Why is my URL showing the wrong title or description when shared?

The wrong sharing text usually comes from missing

Open Graph tags

, conflicting metadata sources, stale platform caches, or JavaScript-injected tags that are not rendered consistently.

Check title, meta description, og:title, og:description,

Twitter Cards

, and the canonical URL together to find the mismatch.

Why is my og:image missing or not showing?

A missing social image usually means

og:image

is absent, blocked, too large, too small, or cached incorrectly by the platform.

Use a valid public image URL, ideally around 1200x630, and verify that both Open Graph and Twitter image tags point to the right file. If you need to generate one quickly, use the screenshot API or the screenshot guide.

Social networks aggressively cache link previews. This validator fetches the live version of your URL, acting as a "fresh" crawler.

Agent Spoofing: We simulate the User-Agent of bots (Googlebot, Twitterbot) to show you exactly what they see.
Rendered HTML: Unlike standard scrapers, we can execute JavaScript to capture meta tags dynamically injected by React/Vue apps.

Update your metadata using our recommended patterns, then re-run the test to verify the fix.

What can I debug with this tool?

This link preview debugging tool inspects and debugs metadata HTML markup, ensuring accurate titles, descriptions, and images across all major social networks.

It runs on

Metascraper

, the battle-tested library maintained by Microlink. We don't just regex HTML; we use a flexible rule-based system to normalize metadata from the wildest edge cases on the web.

We normalize data into a unified JSON response, prioritizing the most relevant source automatically.

In the era of link unfurling (Facebook, X, LinkedIn, etc.), your og:image is your first impression. Manually designing assets for every dynamic route is unscalable, but generic logos get ignored.

Microlink solves this with its screenshot API — pass a URL, get a production-ready image back.

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://www.netflix.com/title/80057281' URL with 'screenshot' API parameter:

CLI Microlink API example

microlink https://www.netflix.com/title/80057281&screenshot

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://www.netflix.com/title/80057281" \
  -d "screenshot=true"

JavaScript Microlink API example

import mql from '@microlink/mql'

const { data } = await mql('https://www.netflix.com/title/80057281', {
  screenshot: true
})

Python Microlink API example

import requests

url = "https://api.microlink.io/"

querystring = {
    "url": "https://www.netflix.com/title/80057281",
    "screenshot": "true"
}

response = requests.get(url, params=querystring)

print(response.json())

Ruby Microlink API example

require 'uri'
require 'net/http'

base_url = "https://api.microlink.io/"

params = {
  url: "https://www.netflix.com/title/80057281",
  screenshot: "true"
}

uri = URI(base_url)
uri.query = URI.encode_www_form(params)

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
response = http.request(request)

puts response.body

PHP Microlink API example

<?php

$baseUrl = "https://api.microlink.io/";

$params = [
    "url" => "https://www.netflix.com/title/80057281",
    "screenshot" => "true"
];

$query = http_build_query($params);
$url = $baseUrl . '?' . $query;

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET"
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
    echo "cURL Error #: " . $err;
} else {
    echo $response;
}

Golang Microlink API example

package main

import (
    "fmt"
    "net/http"
    "net/url"
    "io"
)

func main() {
    baseURL := "https://api.microlink.io"

    u, err := url.Parse(baseURL)
    if err != nil {
        panic(err)
    }
    q := u.Query()
    q.Set("url", "https://www.netflix.com/title/80057281")
    q.Set("screenshot", "true")
    u.RawQuery = q.Encode()

    req, err := http.NewRequest("GET", u.String(), nil)
    if err != nil {
        panic(err)
    }

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

import mql from '@microlink/mql'

const { data } = await mql('https://www.netflix.com/title/80057281', {
  screenshot: true
})

Instead of storing static JPEGs, simply pass your page's URL to Microlink with screenshot=true. We spin up a headless browser, capture the viewport, and serve a globally cached image.

Always Fresh: Your social cards automatically reflect your latest UI updates.
Zero Maintenance: No more Photoshop or Figma templates for every blog post.
High Performance: Served via global CDN, ensuring link previews load instantly.

Can I automate this process?

You can automate your Open Graph and SEO audit workflow using the Microlink API. This allows you to programmatically validate metadata for thousands of URLs without manual intervention.

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://microlink.io' URL with 'meta' API parameter: