# web-clipper-templates is a community template set for Obsidian Web Clipper

> web-clipper-templates collects JSON templates that tell the official Obsidian Web Clipper extension how to turn a page on a given site into a well formed note. The schema is small and learnable, but every template depends on a site specific selector that can rot.

**community-archive/web-clipper-templates** — Community collection of templates for the official Obsidian web clipper.

- Repository: https://github.com/community-archive/web-clipper-templates
- Stars: 866 · Forks: 64
- Language: Unknown
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/community-archive-web-clipper-templates

## A template set for the official Obsidian Web Clipper

This repository is a community collection of templates for the official Obsidian Web Clipper extension, whose own repository is obsidianmd/obsidian-clipper. The extension is a browser extension that captures a web page into a note inside a vault, and the template is the part that says what to capture and how to shape it.

What the project is not is a fork of the extension. Nothing here changes the extension, and there is no code to run. The whole contribution unit is a JSON file that a person pastes into the extension's own template editor.

That makes the audience specific: Obsidian users who clip repeatedly from the same sites and are tired of the default note shape. The project also states plainly that it is still under construction, which is the right thing to know before you treat the catalogue as complete.

The extension works in Chrome, Firefox and Safari, and the project points to the Obsidian documentation page for what the clipper is, to the #obsidian-clipper channel on the Obsidian Discord for questions, and to the extension's own issue tracker for extension bugs. That last routing matters, because a template that clips badly is a different problem from a broken extension.

## The schema is seven fields and one selector

The template format is small enough to read in a minute. This is the shape the project documents:

```json
{
  "schemaVersion": "0.1.0",
  "name": "Example",
  "behavior": "create",
  "noteNameFormat": "{{published|date:\"YYYY-MM-DD\"}} EXAMPLE {{title|safe_name}}",
  "path": "webclips",
  "context": "{{selectorHtml:article|markdown|slice:0,8000|trim}}",
  "properties": [{ "name": "Source", "value": "{{url}}", "type": "text" }],
  "triggers": ["https://example.com", "schema:@Article"],
  "noteContentFormat": "# {{title}}\n\n{{context}}"
}
```

The interesting field is context. It starts from selectorHtml:article, which pulls the article element, then pipes that through markdown, then a slice that caps the length at 8000 characters, then trim. The pipe syntax is the whole extraction model: you name a source, transform it, and decide how much of it to keep.

The other fields are conventional. name is the label you see in the extension, behavior is create in this example, path decides the folder in the vault, properties attaches frontmatter such as a Source field holding the page URL, noteNameFormat builds the file name from template expressions like a published date and a title passed through safe_name, and noteContentFormat is the Markdown body.

## Copying a template into the extension takes four steps

The quick start is deliberately manual. You install the Web Clipper extension in your browser, open Templates and create a new template in the extension, copy JSON from the templates folder of this repository and paste it into that template, then visit a matching site and clip using it. A site matches when its URL or page type satisfies the triggers array.

Validating the JSON before saving is the one step worth not skipping, and the project gives a command for it on Windows PowerShell:

```powershell
Get-Content -Raw .\templates\<file>.json | ConvertFrom-Json > $null
```

The point of the validation is that a malformed template gives you a confusing failure at clip time rather than a clear error at save time.

The trigger array is the part to get right when you paste a template in. The documented convention is to include both a hostname pattern and a schema marker such as schema:@Article wherever possible, so the template activates on the right pages of the right site rather than on every page of that domain.

## Selectors are where a template quietly rots

The conventions section tells contributors to use selectorHtml:article with sensible fallbacks, for example main or .pw-post-body, and to add cleanup filters that remove media tags, collapse more than two consecutive newlines and strip code fences.

Those fallbacks are not decoration. A template that only knows the article element will clip nothing on a site whose markup has no single article container, and a template that knows exactly one selector will break the day that site changes its template. The cleanup filters exist for the same reason: raw page HTML carries navigation, images and preformatted blocks that make a note unreadable.

The troubleshooting notes make the failure mode explicit. When content is missing or the context is insufficient, the site's DOM is different from what the template expects, and the fix is to update the selector fallbacks and the cleanup filters. When a site updates and a template breaks, the project asks for an issue with the URL and the expected output.

That is the honest limit of this project. A template is a snapshot of a site's markup, and no amount of JSON fixes a site that reorganises its pages.

## The catalogue covers summaries, releases and video

The listed templates show the range of shapes people want. A medium-concise-summary-clipper.json file turns a medium article into a concise summary plus key points, a github-releases-clipper.json file extracts the release notes Markdown body from GitHub Releases pages, and a youtube-with-transcript-clipper.json file handles a video together with its transcript.

Those three examples differ in what they capture rather than in how they are configured. The GitHub one is narrow, a single page element that holds the release body. The YouTube one pulls in a transcript, which means it depends on that transcript being available for the video. The summary one is a judgement about how much of a long article is worth keeping, which is where the slice and cleanup filters do the real work.

Around the templates sit four supporting directories. Template-guides holds how to guides for specific sites and templates, Clipper-guides holds general walkthroughs of the clipper itself, Resources holds reference notes such as selector and clipper documentation, and Images holds screenshots for the guides. The repository also carries a .obsidian directory, so the guides themselves are readable as an Obsidian vault.

## Contributions are reviewed against a four line checklist

The contribution rules are short enough to state exactly. A pull request needs valid JSON that passes lint and validation, accurate triggers and selectors that hold up, a reasonable noteNameFormat and path, testing on two or more example pages, and notes about any special behaviour or caveats that apply.

The two or more example pages rule is the most useful line in that list. It is the acknowledgement that a template cannot be verified by looking at it, only by clipping with it. A contributor who has tested a template against two different pages on the same site has a reasonable chance of having written fallbacks that generalise.

The checklist also implies the acceptance bar for selectors: a template has to still work when the page is not the one you developed against, and a PR that only handles the example in the issue will be asked for more.

Contributing is described as reading CONTRIBUTING.md, and the project says it welcomes new templates and improvements to existing ones.

## Writing your own template versus reusing one here

The alternative to using this collection is to write a template yourself in the extension's editor, which takes a few minutes once you know the field names. The difference in approach is that a hand written template is scoped to the sites you personally clip, while these are templates that other people have already tuned against a particular site and left behind for reuse.

That reuse has a cost that comes with it. A template in this repository carries the assumptions of its author, including their idea of a sensible path and a sensible note name, and it may assume a fallback selector that does not exist on the page you are looking at. A template you write yourself can use a path that matches your own vault conventions and a noteNameFormat that matches how you want files sorted.

The pragmatic approach is to treat these as starting points. Copy the closest template, adjust the path and noteNameFormat to your conventions, then adjust the selector fallback if the clip comes back empty.

On maintenance, the repository is not archived and the last push was on 2026-04-11, which is several months behind the present date, so the catalogue reflects the sites as they looked in April rather than today. The licence is MIT, with the details in the LICENSE file at the root, and this page offers no legal reading of it.

## Conclusion

web-clipper-templates is worth borrowing from when you clip the same handful of sites every week, since the schema fields and the selector fallback pattern save the guesswork, and the contribution rules make it easy to add one for a site you know. It is the wrong tool if you need templates that survive site redesigns, because each one hardcodes a selector and a trigger, and the project itself says it is still under construction. Before depending on it, copy one template JSON into a new template in the extension, validate it, then clip from the matching site and check the note name, the path and the extracted context against the page you expected.

## FAQ

### How do I install a template from web-clipper-templates into Obsidian Web Clipper?

Create a new template in the extension under Templates, then copy the JSON from the templates folder of the repository and paste it in. Then visit a site that matches the template triggers and clip with that template.

### What fields does a web-clipper-templates JSON template need?

The documented structure includes schemaVersion, name, behavior, noteNameFormat, path, context, properties, triggers and noteContentFormat. The context field extracts the page with selectorHtml and applies transforms such as markdown, slice and trim.

### Why does a clipped note come back empty or missing content?

The project says the site DOM is probably different from what the template expects. The fix is to update the selectorHtml fallbacks and the cleanup filters, and to report the URL plus the expected output as an issue when a site update breaks a template.

## Sources

- [community-archive/web-clipper-templates on GitHub](https://github.com/community-archive/web-clipper-templates)
- [Issues](https://github.com/community-archive/web-clipper-templates/issues)
- [License: MIT](https://github.com/community-archive/web-clipper-templates/blob/main/LICENSE)
- [README](https://github.com/community-archive/web-clipper-templates/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/community-archive-web-clipper-templates