Skip to content

Website Metadata API for developers

Turn any URL into normalized JSON. A single REST endpoint that executes JavaScript, merges Open Graph, JSON-LD, and HTML tags, and returns structured data instantly.

Get Started 
Detected
  • title
  • description
  • lang
  • author
  • publisher
  • date
  • url
  • image
  • logo
  • video
  • audio
https://api.microlink.io?url=https://stripe.com
Send the URL Get the metadata back
2.0
secs
P95 cold response
-
loading…
99.9
%
SLA Guaranteed
Sources merged
Open GraphTwitter CardsJSON-LDoEmbedMicrodataHTML
https://api.microlink.io?palette&url=https://stripe.com
Drop-in link previews in one line of code 
Build social previews
that actually render
Microlink returns a unified JSON response — plus the brand color palette, logo, and favicon. Everything you need to render a pixel-perfect link preview or URL preview on the first try.
Every source merged, zero parsing
Open Graph, Twitter Cards, JSON-LD, oEmbed, microdata, RDFa, and HTML tags combined into one unified schema. Stop writing per-site fallback logic and ship consistent previews at scale.
Brand-ready visuals out of the box
Get high-resolution images, logos, favicons, and the dominant color palette for every URL — perfect for rich link cards and theming without manual art direction.
Real browser, SPA-ready rendering
Every request runs in a real headless Chrome session that executes JavaScript, hydrates SPAs, and waits for selectors — so you get accurate metadata from dynamic pages that plain scrapers miss.
Production-grade edge infrastructure
Global CDN caching, automatic retries, and 99.9% uptime handle the scraping complexity for you — with a free tier of 50 requests per day to get started.
Metadata API 
 in 
The Microlink website metadata API delivers unified structured data through a developer-friendly HTTP endpoint. One URL in, normalized metadata out — ready to power link previews, URL previews, content ingestion, and social card generation.
Read the docs 
The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://stripe.com' URL with 'meta' API parameter:
CLI Microlink API example
microlink https://stripe.com&meta
cURL Microlink API example
curl -G "https://api.microlink.io" \
  -d "url=https://stripe.com" \
  -d "meta=true"
JavaScript Microlink API example
import mql from '@microlink/mql'

const { data } = await mql('https://stripe.com', {
  meta: true
})
Python Microlink API example
import requests

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

querystring = {
    "url": "https://stripe.com",
    "meta": "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://stripe.com",
  meta: "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://stripe.com",
    "meta" => "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://stripe.com")
    q.Set("meta", "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))
}
Last month usage
641.1M
reqs per month
7%
cache hit rate
14TB
data served
some clients
Community
Fan engagement platform
Impact
Partnership management
Mirror
Web3 publishing platform
Padlet
Visual collaboration tool
SkedSocial
Marketing platform
Start free, scale when ready
No login required. No credit card needed. The website metadata API is free to use — just start calling it.
Free
$0
/month
Free metadata API — 50 requests/day, no login, no credit card.
Unified metadata extraction
Open Graph, Twitter, JSON-LD, oEmbed
Color palette & logo detection
Screenshots, PDF, and more
Full browser control
Get started free 
Pro
€39
/month
46,000 requests/month for production metadata workloads.
Everything in Free
Automatic proxy resolution
Custom HTTP headers
Configurable TTL
Antibot protection
See all plans 
metascraper
The rule-based library that powers Microlink metadata. Normalize Open Graph, JSON-LD, Twitter Cards, microdata, RDFa, oEmbed, and HTML tags from any website.
JavaScript
2.7k
browserless
The headless Chrome/Chromium driver on top of Puppeteer. Renders JavaScript-heavy pages so metadata injected at runtime is captured correctly.
JavaScript
1.8k
sdk
Make any URL embeddable. Turn any URL into a beautiful link preview using the metadata returned by the Microlink API.
JavaScript
618
Built on open source,
trusted by developers
The Microlink metadata engine is powered by 
metascraper
, our battle-tested open source library used by thousands of developers worldwide. You can inspect the code, contribute, or self-host it.
Explore on GitHub 
One API, every layer of context
Metadata is the foundation.
Stack the rest on top.
Use the metadata API on its own to power link previews, knowledge graphs, content moderation, or SEO tooling. Combine it with the other Microlink utilities in a single request to enrich the response with screenshots, PDFs, clean markdown, and brand colors — no extra roundtrips, same predictable JSON, same browser session.
Metadata × Markdown
Clean content for LLMs and RAG pipelines
Strip pages down to clean markdown for embeddings, summarization, or content ingestion — and ship the structured metadata alongside as front-matter. Your AI pipeline gets both the readable body and the trustworthy source signals in one request.
api.microlink.io?meta&markdown&url=https://stripe.comExplore Markdown API
Metadata × Screenshot
Visual link previews, every time
Pair structured metadata with a real browser screenshot when og: Image is missing, low-resolution, or mismatched. render rich link previews and social cards that always look intentional — even for pages without proper Open Graph tags.
api.microlink.io?meta&screenshot&url=https://stripe.comExplore Screenshot API
Metadata × PDF
Document-grade archives with provenance
Convert any URL into a high-fidelity PDF and attach the unified metadata as machine-readable context — title, author, language, publication date, canonical URL. Perfect for legal archives, research evidence, and audit trails.
api.microlink.io?meta&pdf&url=https://stripe.comExplore PDF API
Metadata × Palette & Logo
Brand-aware UI without manual art direction
Add palette=true to extract dominant colors from the og: Image or logo, and get the logo / favicon URLs in the same response. theme link cards, chat unfurls, and notification ui to match the source — pixel by pixel, brand by brand.
api.microlink.io?meta&palette&url=https://stripe.comRead palette docs
Try it live, right now
Skip the setup. Our sharing debugger tool lets you paste any URL, see every extracted metadata field, and preview how link unfurls render on facebook, X, linkedin, whatsapp, and slack in real time.
Sharing Debugger
Validate Open Graph, Twitter Cards, JSON-LD, microdata, and every other meta tag in one place. Preview how your URL renders on Facebook, X, LinkedIn, Slack, and more — before you hit publish.
The most complete website metadata API built for production workloads
Six metadata sources merged into one JSON response.
From Open Graph to JSON-LD, Microlink extracts the full picture in a single round-trip — no brittle scrapers, no partial results.
Read the metadata guides 
The most complete website metadata API, with no compromises.
No more brittle scrapers, conflicting tag sources, or partial link previews — our website metadata API turns any URL to metadata in one predictable JSON response, with easy integration via the metadata API documentation.
  • Unified Metadata Extraction
    Normalize Open Graph, Twitter Cards, JSON-LD, oEmbed, microdata, RDFa, and raw HTML tags into a single, predictable JSON response. One API call, every source merged.
  • Free to Start
    Extract metadata from any URL immediately. No setup fees, no credit card required, and pay-as-you-grow pricing that scales with your link preview and ingestion workloads.
  • Global Edge Delivery
    Metadata responses are cached and distributed across 240+ edge locations powered by Cloudflare, ensuring sub-second link previews and feed ingestion worldwide.
  • Language-Agnostic REST API
    A single REST endpoint designed for developers. Integrate in minutes using official SDKs for Node.js, Python, Ruby, and Go, or any standard HTTP client.
  • Smart Color Palette Detection
    Extract brand palettes and dominant image colors automatically. Perfect for theming link previews, hero cards, and chat unfurls with zero manual art direction.
  • Rich Media & Provider Support
    Detect logos, favicons, videos, audio, and embeddable iframes across 250+ verified providers, from YouTube and Spotify to Figma and CodeSandbox.
  • JavaScript-Rendered Pages
    Full headless browser execution means React, Vue, and Next.js sites that inject meta tags at runtime are captured correctly every time — no stale SSR required.
  • Smart TTL Caching
    Configure Time-To-Live caching rules to keep your metadata fresh. Stay up to date with source changes while maintaining sub-second API performance at scale.
  • Zero-Config Integration
    Interactive documentation packed with live code examples. Copy-paste ready snippets get you from URL to structured metadata in under a minute.
  • Unified Metadata Extraction
    Normalize Open Graph, Twitter Cards, JSON-LD, oEmbed, microdata, RDFa, and raw HTML tags into a single, predictable JSON response. One API call, every source merged.
  • Free to Start
    Extract metadata from any URL immediately. No setup fees, no credit card required, and pay-as-you-grow pricing that scales with your link preview and ingestion workloads.
  • Global Edge Delivery
    Metadata responses are cached and distributed across 240+ edge locations powered by Cloudflare, ensuring sub-second link previews and feed ingestion worldwide.
  • Language-Agnostic REST API
    A single REST endpoint designed for developers. Integrate in minutes using official SDKs for Node.js, Python, Ruby, and Go, or any standard HTTP client.
  • Smart Color Palette Detection
    Extract brand palettes and dominant image colors automatically. Perfect for theming link previews, hero cards, and chat unfurls with zero manual art direction.
  • Rich Media & Provider Support
    Detect logos, favicons, videos, audio, and embeddable iframes across 250+ verified providers, from YouTube and Spotify to Figma and CodeSandbox.
  • JavaScript-Rendered Pages
    Full headless browser execution means React, Vue, and Next.js sites that inject meta tags at runtime are captured correctly every time — no stale SSR required.
  • Smart TTL Caching
    Configure Time-To-Live caching rules to keep your metadata fresh. Stay up to date with source changes while maintaining sub-second API performance at scale.
  • Zero-Config Integration
    Interactive documentation packed with live code examples. Copy-paste ready snippets get you from URL to structured metadata in under a minute.
Start now
Get 50 requests/day with zero commitment — the website metadata API is free to use, no account, and no credit card. Just call the API and go from URL to metadata in seconds.
Get started free 
No login needed
50 reqs/day free
No credit card
Product Information
Everything you need to know about 
 the Microlink metadata API.
What is a website metadata API and how does it work?
A website metadata API takes any URL as input, loads the page with a full headless browser, and returns a unified JSON response containing title, description, image, logo, favicon, color palette, language, author, date, and more. Think of it as a programmable link to metadata: one URL in, fully normalized metadata out.
Which metadata sources does Microlink normalize?
Microlink normalizes seven sources into one response: 
Open Graph
, Twitter Cards, 
JSON-LD
, oEmbed, 
microdata
, 
RDFa
, and HTML head tags.
The API prioritizes the most accurate source per field automatically — you get the best title, description, image, logo, author, date, language, and palette without writing custom parsing logic or maintaining brittle scrapers.
How do I convert a URL to metadata or a link preview?
Use the metadata API as a URL preview and link preview endpoint. Send an HTTPS GET request to https://api.microlink.io?url=<your-url> and you will receive JSON with the normalized metadata — including og:title, og:description, og:image, og:type, and og:site_name.
No authentication is required for the free tier. The response merges Open Graph with Twitter Cards, JSON-LD, and HTML fallbacks so you always get a complete preview — see the metadata guide for all fields.
Does Microlink handle JavaScript-rendered metadata?
Yes. Unlike regex-based scrapers, Microlink runs a full Chromium headless browser. So React, Vue, Next.js, and other SPAs that inject meta tags at runtime are captured correctly.
Metadata added by frameworks like next/head, react-helmet, or Nuxt useHead hooks is detected just as reliably as server-rendered tags. Stale SSR or partial hydration edge cases are handled out of the box.
Can I extract favicons, logos, and brand color palettes?
Yes. Microlink returns the logo and favicon URLs for every page, with dimensions and MIME type.
Add palette=true to the query and you also get the dominant color palette extracted from the og:image or the logo. Perfect for theming link preview cards, chat unfurls, and brand-aware UI without manual design work.
Why use a metadata API instead of scraping the HTML myself?
Metadata extraction looks simple until it is not. Social networks use inconsistent tag naming, some sites inject tags at runtime, JSON-LD can be deeply nested, 
oEmbed
 requires provider-specific endpoints, and encoding bugs are everywhere.
Microlink handles headless browser rendering, rule-based normalization with 
metascraper
, proxy rotation, caching, and concurrency at scale — so you ship features instead of fighting the long tail of the web.
Is there a free tier for the metadata API?
Yes. The metadata API is free to use with 50 requests per day — no login, no credit card, and no setup required. Just call the endpoint and get normalized metadata back.
For production workloads that need higher volume, automatic proxy rotation, custom headers, configurable TTL, and priority support, see our Pro plans starting at €39/month.
How do I integrate the metadata API with Node.js or Python?
In minutes. Visit our documentation for interactive playground examples, official SDKs (Node.js, Python, Ruby, Go), and copy-paste code snippets for any language.
The Microlink SDK turns the metadata response into a rendered link preview component with 250+ verified providers supported out of the box.
What is metascraper and how does it power the API?
metascraper
 is the open-source rule-based library that underpins Microlink. It evaluates each desired field (title, image, date, etc.) against a series of rules and only accepts values that satisfy a strict data shape.
This approach means when the API detects a field, you can be confident it is what it claims to be — no false positives from truncated strings, empty images, or malformed dates. The library is 
open source on GitHub
 and you can contribute rules for your own edge cases.
What is your uptime SLA and expected latency?
We guarantee enterprise-grade reliability with a 99.9% uptime SLA. Every request runs in an isolated browser instance to guarantee security and avoid shared-state leaks. Check real-time availability on the status page.
For latency: metadata responses are distributed via Cloudflare's 240+ edge locations, meaning cached responses are delivered in milliseconds. Our optimized Chromium pool handles cold starts efficiently for consistent P95 performance.
Other questions?
We’re always available at 
[email protected]
.