The Context.dev alternative
that answers in one request

Context.dev prices every answer on a credit menu: markdown is 1, a screenshot is 5, brand data is 10. Microlink returns metadata, logo, brand image, markdown, and screenshots from a single flat-priced request — with a free tier that renews every day.

Get Started Free

Microlink

1 request

Metadata + logo + brand image + palette, in the standard response

Markdown and screenshot on the same request

✓ Everything included — no API key

Context.dev

16 credits

Markdown 1 · screenshot +5 · Retrieve Brand +10

Per URL, across three endpoint calls

Free credits are one-time — 500, or 250 with a consumer email

No key, no signup — see the brand data for context.dev itself:

https://api.microlink.io/?url=https%3A%2F%2Fwww.context.dev

Why Developers Switch

The top reasons teams pick Microlink over Context.dev for URL data.

One request instead of a credit menu

On Context.dev, each answer has a price tag: markdown 1 credit, screenshot 5, extraction 10, Retrieve Brand 10, fonts 5, styleguide 10. Microlink returns metadata, logo, brand image, markdown, and a screenshot from the same request — one flat price, however much it carries.

Brand data is Microlink's home turf

The metadata engine behind Microlink, Metascraper, has been extracting logos, brand images, and publisher data in the open for years — and the logo API adds detection with color palettes and sizing. Normalized brand fields are the default response, not a premium endpoint.

A free tier that refills every day

Context.dev hands you 500 one-time credits — 250 if you sign up with a consumer email — and evaluation ends when they do. Microlink resets 25 free requests every day, forever: no credit card, no API key, testable from the browser address bar.

Screenshots without the 5-credit surcharge

Microlink screenshots cost the same flat request price and come back as CDN-hosted URLs you can embed directly, with browser-frame overlays, device presets, dark mode, and MP4/WebM recordings as parameters. On Context.dev every screenshot bills 5 credits.

No rate-limit ladders

Context.dev meters 30 to 700 API calls per minute depending on the plan you pay for. Microlink paid plans have no per-minute cap and no concurrency limit* — your monthly quota spends at whatever rate your pipeline needs.

An open engine you can audit

Context.dev's entity resolution is proprietary. Microlink's extraction stack — Metascraper, MQL, Browserless — is MIT licensed and developed in public: read the rules that produce your brand data, fork them, or run them yourself.

One request price.
No endpoint menu.

On Context.dev the question isn't how many URLs — it's how many endpoints you touch per URL. On Microlink, one request carries everything.

Microlink

$49/mo

46,000 requests/month

One request can return markdown, metadata, logo, and screenshot together
Brand fields — logo, image, palette — in the standard response
Residential proxy and antibot detection included on Pro
TTL caching up to 31 days — cache hits don't spend your quota
No concurrency limit* and no per-minute cap
Free: 25 requests/day, renews forever, no credit card, no key
330+ edge nodes, 99.9% SLA
~$0.00107/request on this tier

Start for free

Context.dev

$25/mo

10,000 credits/month (Developer)

1 credit per markdown page · screenshots 5 · Extract 10
Retrieve Brand 10 · Fonts 5 · Styleguide 10 · Enrich People 20
Rate limit: 60 API calls/minute on this tier
Overage: $15 per 10K credits
Free: 500 one-time credits (250 with a consumer email)

The credit menu: what a full brand snapshot really costs

Ask for markdown, a screenshot, and brand data on the same URL and Context.dev bills 16 credits across three endpoint calls. Microlink answers all three in one.

Scenario	What happens	Monthly bill
Context.dev — markdown only	46,000 pages × 1 credit — needs the Pro plan (200K credits)	$149/mo
Context.dev — markdown + screenshot + brand per URL	46,000 × (1 + 5 + 10) = 736,000 credits — into the Scale tier	≈ $499/mo
Microlink — all three in one request	46,000 requests, flat price, no menu*	$49/mo

Estimates use Context.dev's published credit rates. Light, single-endpoint workloads fit its $25 Developer plan well — the gap opens when each URL needs more than one answer, since Microlink bundles them into the same flat-priced request.

* Microlink never bills or caps concurrency on legitimate usage. We only restrict usage that is fraudulent or illegal — for example, traffic aimed at attacking other people's sites.

Get the whole answer in one request

Your first 25 requests/day are free — renewed daily, no credit card, no API key.

Start Building Free

Feature-by-Feature Comparison

One bundled request against a credit-metered endpoint menu.

Feature	Microlink	Context.dev
URL to LLM-ready markdown	✓	✓
Metadata extraction	✓	✓
Logo & brand image extraction Context.dev Retrieve Brand bills 10 credits; Microlink includes logo and brand image in the standard response.	✓	✓
Color palette extraction Context.dev styleguide endpoint bills 10 credits.	✓	✓
Screenshot capture Context.dev bills screenshots at 5 credits; Microlink at the flat request price.	✓	✓
Structured data extraction Context.dev Extract bills 10 credits; Microlink MQL selector rules run at the flat request price.	✓	✓
Hotlinkable logo URLs Microlink via embed=logo.url; Context.dev via its Logo Link CDN.	✓	✓
Web search endpoint Microlink Search is a paid workflow from the first request.	✓	✓
Residential proxy / anti-bot bypass Context.dev includes it on every plan; Microlink includes it on Pro plans.	✓	✓
MCP server	✓	✓
CLI	✓	✓
SDKs (multiple languages)	✓	✓
Markdown + metadata + logo + screenshot in one request On Context.dev that bundle is 1 + 10 + 5 = 16 credits across separate endpoint calls.	✓	✕
Free tier that renews daily Context.dev free credits are one-time: 500, or 250 with a consumer email.	✓	✕
Keyless usage (no API key)	✓	✕
No per-minute rate cap Context.dev caps 30–700 API calls/minute depending on plan.	✓	✕
PDF generation (URL → PDF)	✓	✕
Document conversion (PDF/docx/xlsx/pptx → markdown)	✓	✕
Animated capture (MP4/WebM)	✓	✕
Browser chrome overlay	✓	✕
Dark/light mode capture	✓	✕
Direct embed (no backend)	✓	✕
Link previews SDK (React/Vue/JS)	✓	✕
Open-source core (MIT)	✓	✕
Multi-page crawling	✕	✓
Monitors / change detection	✕	✓
Batch jobs (up to 25,000 URLs)	✕	✓
Company enrichment (NAICS/SIC, tickers, people)	✕	✓
Transaction / merchant identification	✕	✓

Last verified: August 2026. See each product's docs for the latest.

Where Context.dev
Might Be the Right Choice

You need company enrichment, not just page data

NAICS and SIC classification, ticker and ISIN resolution, transaction and merchant-descriptor identification, email-to-company lookup, and people enrichment make Context.dev a real company-data platform. Microlink extracts what a URL contains — it does not resolve corporate entities.

Resolved brand entities across the web

Context.dev positions its brand data as canonical entities resolved across sources, not a single-page extraction. If your product needs the one true logo and identity for a company rather than what a given URL declares, that resolver is the point.

Crawling, monitors, and batch jobs

Multi-page crawls, page and sitemap monitors with signed webhooks, and batch jobs up to 25,000 URLs cover pipeline shapes Microlink does not — Microlink converts one URL per call and leaves the queue to you.

Cheaper per plain page at high volume

The Pro plan works out to about $0.75 per 1,000 markdown pages versus roughly $1.07 on Microlink. If your workload is pure single-endpoint scraping at scale and nothing else, Context.dev can be the cheaper line item.

Ship the whole answer

25 requests/day free — no account, no credit card. Metadata, logo, and brand image from any url.

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))
}

import mql from '@microlink/mql'

const { data } = await mql('https://stripe.com', {
  meta: true
})

Start now for free

Is there a Context.dev alternative that returns brand data in one request?

Yes — that is how Microlink has always worked. The standard response for any URL already includes normalized metadata: title, description, publisher, logo, brand image, and color palette. No dedicated brand endpoint, no 10-credit surcharge.

Add markdown or a screenshot to the same request and it still costs one request. On Context.dev, that bundle is three endpoint calls billed at 1 + 10 + 5 = 16 credits per URL.

How does Microlink pricing compare to Context.dev credits?

Context.dev prices a menu: markdown is 1 credit, a screenshot is 5, structured extraction is 10, Retrieve Brand is 10, fonts 5, styleguide 10, people enrichment 20 — on plans from $25/month for 10,000 credits to $499/month for 1M, with 30–700 API calls/minute rate caps.

Microlink prices requests: $49/month covers 46,000 of them, whatever each one returns, with no per-minute cap and cache hits free. The more endpoints you would touch per URL over there, the bigger the gap gets.

Can Microlink extract logos and brand assets like Context.dev?

Yes — brand data is Microlink's home turf. The metadata engine, Metascraper, has been extracting logos, brand images, and publisher data in the open for years, and the logo API adds detection with color palettes and sizing information.

Need a hotlinkable asset? embed=logo.url turns the API URL into the logo itself — the response mimics the original resource's headers and body, so it drops straight into an image tag.

Does Microlink return LLM-ready markdown like Context.dev?

Yes. Any URL — a web page, a PDF, or a docx, xlsx, or pptx document — converts to clean markdown with about 80% fewer tokens than raw HTML. See the URL to markdown guide, or use the one-line shortcut endpoint markdown.microlink.io/{url}.

Adblock ships enabled by default, so ads, trackers, and cookie banners are stripped before conversion.

Which Context.dev features does Microlink not cover?

The company-data layer: NAICS and SIC classification, ticker and ISIN resolution, transaction and merchant-descriptor identification, email-to-company lookup, and people enrichment. Microlink extracts what a URL contains — it does not resolve corporate entities behind it.

Multi-page crawling, page monitors, and 25,000-URL batch jobs are also Context.dev territory. If those are the core of your workload, it is a genuinely different product.

Do free credits expire on Context.dev and Microlink?

Context.dev's free tier is one-time: 500 credits with a work email, 250 with a consumer one — once spent, evaluation is over. Microlink's free tier renews: 25 requests every day, forever, with no credit card and no API key.

Over a year that is more than 9,000 free requests — enough to keep a side project running on the free tier alone.

How do I migrate from Context.dev to Microlink?

Both are GET APIs, so migration is mostly URL rewriting: drop the Bearer header (the free tier needs no key), swap /web/scrape/markdown?url= for ?url= plus data.markdown.attr=markdown, and delete the separate brand and screenshot calls — metadata comes standard and screenshot is a parameter on the same request.

Start from the markdown guide and the metadata guide.

Can I audit how Microlink extracts brand data?

Yes — the extraction rules are public code. Metascraper (the metadata and brand engine), MQL, and Browserless are MIT licensed and developed in the open, used by thousands of projects beyond Microlink itself.

Context.dev is a proprietary platform: its entity-resolution logic is a black box you can only observe from outside.

The Context.dev alternativethat answers in one request