Metafetch

Turn a URL in a note's frontmatter into a link card's worth of metadata: title, description, share image, favicon, site name, authors, and publication date. Use it with no API key, or through OpenGraph.io or Microlink.

Requires Obsidian 1.13 or newer. Desktop only.

Why Care?

We manage our site-wide content in Obsidian. Our toolkit section reviews applications and web services, and each review is a note whose frontmatter becomes a card on the site. Metafetch fills in those cards.

It works the same way for notes about papers, articles, and companies. Fetch once, and Bases, Dataview, or your published site can show the source properly.

What's new in 0.2.0

• The share image comes through. Direct Fetch finds it in og:image (including its :url and :secure_url forms), twitter:image, schema.org microdata, <link rel="image_src">, and JSON-LD. It reads tags however the page writes them.
• Nothing gets erased. If a page has no image, title, or description, your note keeps the one it had.
• Better authors, cleaner text. Apostrophes and HTML entities come through intact. Bylines are found in JSON-LD and visible author lines, and reading times are no longer stored as authors. Bot-check pages count as a failed fetch.
• Socials from a folder profile. For a note under Tooling/, Metafetch reads the company's homepage and fills its GitHub org and repo, LinkedIn page, X, YouTube, Discord, and more. It only fills empty fields, and when the page links two equally likely profiles it writes neither.
• Funding rounds in the note. Fetch via Fireround writes a company's rounds under ## Fundraising History as a json block, exactly as they arrived, and keeps them out of your frontmatter.
• Any data API, for what a page doesn't say. from: [direct, firecrawl] falls back to Firecrawl when a site refuses a plain fetch, and Firecrawl Branding adds colours and fonts. One Firecrawl key covers all of it, and any other JSON API is a recipe file, with its own command if you want one.
• Any model, for the fields a page can't fill. Mark a profile field from: [model] and Claude, OpenAI, TrustedRouter, a local LM Studio, or any API you describe in a recipe file fills it from the page's text. Keys stay in Obsidian's keychain.
• Searchable settings on Obsidian 1.13's settings API.

Full notes: changelog/releases/0.2.0.md.

Commands

What lands in frontmatter

url: "https://arxiv.org/abs/2305.10601"
og_title: "Tree of Thoughts: Deliberate Problem Solving with Large Language Models"
og_description: "Language models are increasingly being deployed for general problem solving…"
og_image: "https://arxiv.org/static/browse/0.3.4/images/arxiv-logo-fb.png"
og_favicon: "https://arxiv.org/static/browse/0.3.4/images/icons/favicon-32x32.png"
og_site_name: "arXiv.org"
og_type: "website"
authors:
  - Shunyu Yao
  - Dian Yu
  - Jeffrey Zhao
  - Izhak Shafran
  - Thomas L. Griffiths
  - Yuan Cao
  - Karthik Narasimhan
og_published: "2023-05-17"
og_last_fetch: "2026-10-08T15:04:05.000Z"

Every key name is configurable under Settings → Metafetch → Field names. An optional vault identity code (hex_code: k4m2x9) can be stamped on each fetched note, so you can reference it by something steadier than its filename.

Folder profiles

A folder profile says which frontmatter a folder's notes should carry. It's an ordinary note in zz-cf-lib/frontmatter/, so you edit it in Obsidian:

---
title: Tooling socials
applies-to-paths:
  - "Tooling/**"
---

```metafetch-profile
fields:
  github_profile_url: { platform: github-org, aliases: [github_profle_url] }
  github_repo_url:    { platform: github-repo }
  linkedin_url:       { platform: linkedin-company }
  x_url:              { platform: x }
  og_image:           { page: image, aliases: [image] }
```

Run Create example frontmatter profile to get the full Tooling version, then Fill frontmatter from folder profile on a Tooling note. How a social link is chosen:

1. Profiles the site lists in its structured data (JSON-LD sameAs) win.
2. Then links in the footer, then in the header or navigation.
3. A handle that resembles the site's domain or name counts in its favour.
4. A link only in the page body, unrelated to the brand, is never used. That keeps customer logos and partner links out.
5. If two links tie, neither is written, and the notice names both.

A field that already has a value, under its own name or an alias, is never changed.

Fields a model fills

Some fields need judgment rather than a link: a one-line zinger, a pricing model, a category. Mark them from: [model] with an instruction:

  zinger:
    from: [model]
    describe: "One punchy sentence, under 90 characters, saying what this does and for whom."
  pricing_model:
    from: [model]
    type: enum
    values: [free, freemium, paid, open-source, enterprise]
    describe: "How the product charges."

After the free fields are filled, the ones still empty go to a model in one call per note, along with the page's text. The reply is checked against each field: a value outside an enum or list is dropped, and the model is told to return nothing rather than guess. Social links and other URLs are never asked of a model.

Fields a data API fills

Some facts aren't on the page at all: who led the last round, how much it raised. Others are, but the site refuses a plain fetch. Name a data recipe in a field's from: list and the output to read in value::

  og_image:
    page: image
    from: [direct, firecrawl]       # the page first; Firecrawl if the site refuses
  latest_round:
    from: [fireround]
    value: round                    # "Series B"
  latest_round_amount:
    from: [fireround]
    value: amount                   # "$75M"
  lead_investors:
    from: [fireround]
    value: lead_investors           # a list
  brand_color:
    from: [firecrawl-branding]
    value: primary_color

Sources run in order: the free parse, then data recipes, then a model, which only fills what nothing else could. Each recipe is called at most once per note, and only while a field still needs it. The recipe's output names stay in the recipe; your vault's key names stay in the profile, so either can change without the other.

Fireround is matched on the note's domain, so a company with a similar name is never written. A field the source has no value for stays empty.

Providers

Settings → Metafetch → Providers lists one group per key. Model providers each have a key and a model:

The Firecrawl group holds one key for firecrawl, firecrawl-branding, and fireround, and that key only ever goes to api.firecrawl.dev.

API keys are picked from Obsidian's keychain, never typed into Metafetch's settings file. The keychain belongs to the vault, so one secret named anthropic works for every plugin that uses it. Each key goes only to its provider's own host; a recipe file's key goes nowhere until you approve its host.

To add any other model API, run Create example model recipe and edit the copy. A recipe says where to send the request, where the key goes, what the body looks like (with {{model}}, {{system}}, {{prompt}}, and {{schema}} filled in), and where the reply's text is. Recipes are data only, never code.

A data recipe is the same, with kind: data and named outputs instead of reply text. Its body can use {{url}}, {{domain}} (the note's URL without www.), and {{title}}. With provider: firecrawl it borrows the Firecrawl key, which can still only go to Firecrawl's host. That makes anything in Firecrawl's provider catalogue one file away:

```cf-recipe
id: my-catalogue-lookup
kind: data
provider: firecrawl
title: My catalogue lookup
request:
  url: https://api.firecrawl.dev/v2/scrape
  body:
    alexandria: { provider: <provider>, capability: <capability>, options: { domain: "{{domain}}" } }
response:
  error: data.alexandria[0].error          # a provider error inside a 200
  records: data.alexandria[0].data.data    # a list of results…
  match: { domain: "{{domain}}" }          # …of which only an exact match is read
  outputs:
    founded: founded_year
    founders: founders[*].name             # [*] reads every element: a list
    website: [website, homepage]           # the first path that has a value
```

Add write-json-under: "Some Heading" under response: and the recipe gets its own Fetch via command, like Fetch via Fireround. It writes the raw records into the note body as a json block under that heading, replacing any block already there, so a large answer stays out of your frontmatter. json-key: names the key they sit under, and homepage-only: true at the top level of the recipe skips notes whose url is a deeper page. The command appears after a rescan or the next time a recipe is loaded.

A data recipe with no provider: holds its own key, and that key goes nowhere until you approve its host in settings. Values are written only as text, numbers, yes/no, or lists of those; objects and inline data: images are dropped.

Getting started

1. In Settings → Community plugins, search for "Metafetch", install it, and enable it.
2. Add a url: property to a note.
3. Open the command palette (Cmd+P / Ctrl+P) and run Metafetch: Direct fetch from script.

For the OpenGraph.io commands, add your key under Settings → Metafetch → OpenGraph.io. Free keys are available at opengraph.io.

Metafetch also works with Microlink.

For developers

Metafetch builds with pnpm and esbuild, and has no runtime dependencies.

git clone https://github.com/lossless-group/metafetch.git
cd metafetch
pnpm install
pnpm dev     # watch build to main.js
pnpm test    # node:test suites, no framework
pnpm lint    # the Obsidian review bot's rules (eslint-plugin-obsidianmd)
pnpm build   # type-check + production bundle

pnpm-workspace.yaml is this plugin's own pnpm settings file, so it installs and builds on its own even inside a larger checkout.

To try a build in your vault, symlink the repo into the vault's plugin folder, then fully quit and reopen Obsidian (Obsidian reads main.js only at startup):

ln -s "$(pwd)" "<your-vault>/.obsidian/plugins/metafetch"

Releases are built and published by .github/workflows/release.yml when a version tag is pushed. The assets carry build-provenance attestations:

gh attestation verify main.js --repo lossless-group/metafetch

License

The Unlicense. Made by The Lossless Group.