Obsidian
Obsidian v1.2.0
Work with your local vault
From the developer
Not specified in the available declarations: capabilities, limitations, pricing & account requirements.
Onboarding example
Find notes about my current project and summarize the open tasks.
Sources & dates
Developer declarations; not independently tested. Listing last checked Nov 18, 2026. Package observed Nov 18, 2026.
Description
From the marketplace listing
Search, read, create, and organize notes in a local Obsidian vault. Create and edit Obsidian Markdown with links, properties, and callouts. This plugin also lets you build Bases views, Canvas diagrams, extract web pages to Markdown, render templates, and sync and publish vaults with Obsidian Headless. This plugin is currently desktop-only and requires Obsidian to be open and running with the CLI enabled. In the future we will add MCP so you can interact with your vault remotely and in the ChatGPT mobile app.
Language: English · Automatically detected from descriptions.
Changes
No changes recorded yet. Follow this plugin to keep track of future changes.
First seen Nov 18, 2026. Last seen Nov 18, 2026.
Similar plugins
Find competitors to follow as you develop your plugin.
-
Miyo lets users search their local notes and knowledge base, read full files, browse folders and indexed files, and create or edit files ...
Shared terms: local, base, desktop, note
-
Connect AI agents to Heptabase to search, read, create, and update knowledge through the hosted MCP server.
Shared terms: base, desktop, local, mobile
-
Search, read, write and organize your Caliu notes.
Shared terms: local, markdown, organize, web
-
Search, read, create and edit notes in Wander.
Shared terms: organize, vault, web, publish
-
Ideaflow helps users confirm their signed-in account, open their notes app URL, and search, filter, read, list hashtags, link, create, ed...
Shared terms: organize, publish, note, edit
Keywords
Files & skills
File archives
Skill instructions
defuddle961 Bytes
--- name: defuddle description: Extract clean Markdown from HTML pages with Defuddle CLI. --- # Defuddle Use Defuddle CLI when the user wants clean Markdown extracted from a web page. It removes navigation, ads, and other page clutter. Check availability with `defuddle --help`. If it is missing, explain the dependency and offer installation with `npm install -g defuddle`. Do not claim extraction succeeded if the tool is unavailable or returns an error. ## Usage Always use `--md` for markdown output: ```bash defuddle parse <url> --md ``` Save to file: ```bash defuddle parse <url> --md -o content.md ``` Extract specific metadata: ```bash defuddle parse <url> -p title defuddle parse <url> -p description defuddle parse <url> -p domain ``` ## Output formats | Flag | Format | |------|--------| | `--md` | Markdown (default choice) | | `--json` | JSON with both HTML and markdown | | (none) | HTML | | `-p <name>` | Specific metadata property |
json-canvas8.54 KB
---
name: json-canvas
description: Create and edit JSON Canvas files (.canvas) with nodes, edges, groups, and connections. Use when working with .canvas files, creating visual canvases, mind maps, flowcharts, or when the user mentions Canvas files in Obsidian.
---
# JSON Canvas Skill
## File Structure
A canvas file (`.canvas`) contains two top-level arrays following the [JSON Canvas Spec 1.0](https://jsoncanvas.org/spec/1.0/):
```json
{
"nodes": [],
"edges": []
}
```
- `nodes` (optional): Array of node objects
- `edges` (optional): Array of edge objects connecting nodes
## Common Workflows
### 1. Create a New Canvas
1. Create a `.canvas` file with the base structure `{"nodes": [], "edges": []}`
2. Generate unique 16-character hex IDs for each node (e.g., `"6f0ad84f44ce9c17"`)
3. Add nodes with required fields: `id`, `type`, `x`, `y`, `width`, `height`
4. Add edges referencing valid node IDs via `fromNode` and `toNode`
5. **Validate**: Parse the JSON to confirm it is valid. Verify all `fromNode`/`toNode` values exist in the nodes array
### 2. Add a Node to an Existing Canvas
1. Read and parse the existing `.canvas` file
2. Generate a unique ID that does not collide with existing node or edge IDs
3. Choose position (`x`, `y`) that avoids overlapping existing nodes (leave 50-100px spacing)
4. Append the new node object to the `nodes` array
5. Optionally add edges connecting the new node to existing nodes
6. **Validate**: Confirm all IDs are unique and all edge references resolve to existing nodes
### 3. Connect Two Nodes
1. Identify the source and target node IDs
2. Generate a unique edge ID
3. Set `fromNode` and `toNode` to the source and target IDs
4. Optionally set `fromSide`/`toSide` (top, right, bottom, left) for anchor points
5. Optionally set `label` for descriptive text on the edge
6. Append the edge to the `edges` array
7. **Validate**: Confirm both `fromNode` and `toNode` reference existing node IDs
### 4. Edit an Existing Canvas
1. Read and parse the `.canvas` file as JSON
2. Locate the target node or edge by `id`
3. Modify the desired attributes (text, position, color, etc.)
4. Write the updated JSON back to the file
5. **Validate**: Re-check all ID uniqueness and edge reference integrity after editing
## Nodes
Nodes are objects placed on the canvas. Array order determines z-index: first node = bottom layer, last node = top layer.
### Generic Node Attributes
| Attribute | Required | Type | Description |
|-----------|----------|------|-------------|
| `id` | Yes | string | Unique 16-char hex identifier |
| `type` | Yes | string | `text`, `file`, `link`, or `group` |
| `x` | Yes | integer | X position in pixels |
| `y` | Yes | integer | Y position in pixels |
| `width` | Yes | integer | Width in pixels |
| `height` | Yes | integer | Height in pixels |
| `color` | No | canvasColor | Preset `"1"`-`"6"` or hex (e.g., `"#FF0000"`) |
### Text Nodes
| Attribute | Required | Type | Description |
|-----------|----------|------|-------------|
| `text` | Yes | string | Plain text with Markdown syntax |
```json
{
"id": "6f0ad84f44ce9c17",
"type": "text",
"x": 0,
"y": 0,
"width": 400,
"height": 200,
"text": "# Hello World\n\nThis is **Markdown** content."
}
```
**Newline pitfall**: Use `\n` for line breaks in JSON strings. Do **not** use the literal `\\n` -- Obsidian renders that as the characters `\` and `n`.
**Quote escaping pitfall**: Double quotes inside `text` content must be escaped as `\"`. For example, the text `公司的"外交官"` must be stored as `"text": "公司的\"外交官\""`. Unescaped quotes break the JSON parse and the canvas will fail to render. When generating canvas JSON programmatically, always use a JSON serializer rather than manual string concatenation.
Write `.canvas` files directly. Don't create them with `obsidian create content=`, which turns every `\n` into a raw newline and breaks the JSON.
### File Nodes
| Attribute | Required | Type | Description |
|-----------|----------|----Preview of the first 4,000 characters. Read full instructions →
Referenced files: 1 — file references are metadata, not package contents.
knap4.01 KB
---
name: knap
description: Render Markdown from templates and structured data using Knap CLI. Use when the user asks to apply a Knap template, turn JSON or CSV data into notes, batch-generate Markdown files, or format Defuddle output into a note.
---
# Knap
Use Knap CLI to render Markdown templates with variables, filters, and logic.
Check availability with `knap --help`. If it is missing, explain that Knap requires Node.js 20 or later and offer installation with `npm install -g knap` or execution with `npx knap`. Do not claim a template was rendered if the tool is unavailable or returns an error.
Run `knap --help` for available commands and options. Discover the language through the CLI's offline reference:
```bash
knap help syntax
knap help filters
knap help filter date
knap help tags
knap help tag for
```
Use the lists to find names, then request individual help for syntax, parameters, and examples with expected output.
## Usage
Render a template with JSON variables:
```bash
knap render template.md --data article.json -o note.md
```
Supply a template and data inline:
```bash
knap render -t '# {{ title | trim }}' --data-json '{"title":"Hello"}'
```
Override a variable or pipe JSON data:
```bash
knap render template.md --data article.json --set 'title=Custom title'
cat article.json | knap render template.md --data -
```
Data must be a JSON object; its properties become template variables. `--set` overrides literal top-level keys with strings. Use JSON for nested objects, arrays, numbers, and booleans.
Choose one template source (file, `-t`, or stdin) and one data source (`--data` or `--data-json`). Only one input can read stdin. Without a template file or `-t`, Knap reads the template from stdin.
Output defaults to stdout. `-o` creates parent directories and overwrites the destination after rendering succeeds. Errors exit with status `1`; diagnostics go to stderr. Warnings can accompany successful output.
## Templates
Use `{{ variable }}` for values, `|` for filters, and `{% ... %}` for logic. For example, save this as `template.md`:
```knap
---
{{ title | yaml_property:"title" }}
{{ tags | yaml_property:"tags" }}
---
# {{ title | trim }}
{% if author %}
By {{ author }}
{% endif %}
{{ content }}
```
Use `yaml_property` for complete frontmatter properties so values are quoted and indented correctly. The CLI includes standard filters, but does not supply Web Clipper browser variables, selectors, prompts, or DOM-dependent HTML filters. Supply variables through JSON.
Check a template before rendering:
```bash
knap validate template.md
```
Validation checks syntax, filter names, and static filter arguments without data or file output. It does not check variable existence, runtime values, or dynamic arguments; render with real data to check runtime behavior. Diagnostics go to stderr and include relevant help commands.
## Defuddle pipeline
Extract a web page as JSON with Markdown content, then render it into a note:
```bash
defuddle parse https://example.com/article --md --json \
| knap render template.md --data - -o note.md
```
Defuddle's JSON properties, such as `title` and `content`, become template variables directly.
## Batch rendering
Create one file per CSV row, JSON array object, or JSON file in a folder:
```bash
knap batch template.md --data articles.csv --output-dir notes \
--filename '{{ title | safe_name }}.md'
```
Use `--data articles.json` for an array or `--data ./articles` for a folder of JSON objects. CSV headers become variable names and values remain strings. Piped data defaults to JSON; add `--format csv` for piped CSV.
Use `--dry-run` to validate and list output paths without writing files. Existing files require `--overwrite`, including during a dry run. Duplicate output names within a batch are errors even with `--overwrite`.
Filename templates must produce a single filename with its extension, without directories. Use `safe_name` for data-derived names. Without `--filenaPreview of the first 4,000 characters. Read full instructions →
obsidian-bases16.7 KB
---
name: obsidian-bases
description: Create and edit Obsidian Bases (.base files) with views, filters, formulas, and summaries. Use when working with .base files, creating database-like views of notes, or when the user mentions Bases, table views, card views, kanban boards, filters, or formulas in Obsidian.
---
# Obsidian Bases Skill
## Workflow
1. **Create the file**: Create a `.base` file in the vault with valid YAML content
2. **Define scope**: Add `filters` to select which notes appear (by tag, folder, property, or date)
3. **Add formulas** (optional): Define computed properties in the `formulas` section
4. **Configure views**: Add one or more views (`table`, `cards`, `list`, `map`, or `kanban`) with `order` specifying which properties to display
5. **Validate**: Verify the file is valid YAML with no syntax errors. Check that all referenced properties and formulas exist. Common issues: unquoted strings containing special YAML characters, mismatched quotes in formula expressions, referencing `formula.X` without defining `X` in `formulas`
6. **Test in Obsidian**: Open the `.base` file in Obsidian to confirm the view renders correctly. If it shows a YAML error, check quoting rules below. If it doesn't open as a base at all, check that Bases is turned on in Settings → Core plugins
## Schema
Base files use the `.base` extension and contain valid YAML.
```yaml
# Global filters apply to ALL views in the base
filters:
# Can be a single filter string
# OR a recursive filter object with exactly ONE key: and, or, or not
and:
- 'status == "active"'
- not:
- 'file.hasTag("archived")'
# Define formula properties that can be used across all views
formulas:
formula_name: 'expression'
# Configure display names and settings for properties.
# Note properties need the `note.` prefix here, or the setting is ignored.
properties:
note.property_name:
displayName: "Display Name"
formula.formula_name:
displayName: "Formula Display Name"
file.ext:
displayName: "Extension"
# Define custom summary formulas
summaries:
custom_summary_name: 'values.mean().round(3)'
# Define one or more views
views:
- type: table | cards | list | map | kanban
name: "View Name"
limit: 10 # Optional: limit results
groupBy: # Optional: group results
property: property_name
direction: ASC | DESC
groupOrder: # Optional: only these groups, in this order
- value_one
- null # Files with no value for the groupBy property
sort: # Optional: sort results (supports multiple properties)
- property: property_name
direction: ASC | DESC
filters: # View-specific filters follow the same rules
and:
- 'status == "active"'
order: # Properties to display in order
- file.name
- property_name
- formula.formula_name
summaries: # Map properties to summary formulas
property_name: Average
```
## Filter Syntax
Filters narrow down results. They can be applied globally or per-view.
### Filter Structure
```yaml
# Single filter
filters: 'status == "done"'
# AND - all conditions must be true
filters:
and:
- 'status == "done"'
- 'priority > 3'
# OR - any condition can be true
filters:
or:
- 'file.hasTag("book")'
- 'file.hasTag("article")'
# NOT - exclude matching items
filters:
not:
- 'file.hasTag("archived")'
# Nested filters
filters:
or:
- file.hasTag("tag")
- and:
- file.hasTag("book")
- file.hasLink("Textbook")
- not:
- file.hasTag("book")
- file.inFolder("Required Reading")
```
### Filter Operators
| Operator | Description |
|----------|-------------|
| `==` | equals |
| `!=` | not equal |
| `>` | greater than |
| `<` | less than |
| `>=` | greater than or equal |
| `<=` | less than or equal |
| `&&` | lPreview of the first 4,000 characters. Read full instructions →
Referenced files: 1 — file references are metadata, not package contents.
obsidian-cli6.26 KB
--- name: obsidian-cli description: Interact with Obsidian vaults using the Obsidian CLI to read, create, search, and manage notes, tasks, properties, and more. Also supports plugin and theme development with commands to reload plugins, run JavaScript, capture errors, take screenshots, and inspect the DOM. Use when the user asks to interact with their Obsidian vault, manage notes, search vault content, perform vault operations from the command line, or develop and debug Obsidian plugins and themes. --- # Obsidian CLI Use the `obsidian` CLI to interact with a running Obsidian instance. Requires Obsidian to be open. ## Before using the CLI Run `obsidian help` to check availability. If the command is missing, explain how to turn on the CLI using https://help.obsidian.md/cli. The `obsidian` command ships with the Obsidian installer; don't install the unrelated npm package `obsidian-cli`. If it can't find Obsidian, ask the user to open the desktop app, then retry. In a sandboxed shell the same message can mean the sandbox blocked the CLI's local socket. On WSL, run `Obsidian.com` from the Windows install folder, not `Obsidian.exe`. `Obsidian.com` is the console wrapper that prints the output; `Obsidian.exe` exits without printing anything. The CLI exits with status 0 even when a command fails, so read its output before reporting that a command succeeded. Quote parameters for the current shell, and pass note text as literal argument data, never as executable shell syntax. ## Command reference Run `obsidian help` to see all available commands. This is always up to date. Full docs: https://help.obsidian.md/cli ## Syntax **Parameters** take a value with `=`. Quote values with spaces: ```bash obsidian create name="My Note" content="Hello world" ``` **Flags** are boolean switches with no value: ```bash obsidian create name="My Note" open overwrite ``` Use `overwrite` only when replacing an existing file is intended. Opening is opt-in: pass `open` to open the file, and add `newtab` to open it in a new tab. There is no `silent` flag. In `content=`, `\n` becomes a newline and `\t` a tab. Every `\n` and `\t` is converted and there's no escape, so text such as the LaTeX `\theta` or the path `C:\notes` is corrupted. Write content that contains backslashes, or is longer than about 4 KB, directly to the note's file instead. A dot in a file name is read as the start of an extension. When a name contains a dot, include the extension: `create name="Meeting 2026.11.06.md"`, `rename name="v1.2 notes.md"`, `move to="Archive 2026.10/Note.md"`. ## File targeting Many commands accept `file` or `path` to target a file. Without either, the active file is used. - `file=<name>` — resolves like a wikilink (name only, no path needed). `.md` is optional; other file types need their extension, e.g. `file="Projects.base"`. Aliases don't resolve. - `path=<path>` — exact path from vault root, e.g. `folder/note.md` ## Vault targeting Without `vault=`, commands target the vault that contains the current directory, then the most recently focused vault. `vault=<name>` only works as the first parameter; anywhere else it's ignored: ```bash obsidian vault="My Vault" search query="test" ``` Use `vault=` when the user has selected a vault. If the target is unclear and the user has several vaults, ask which one before changing files. ## Common patterns ```bash obsidian read file="My Note" obsidian create name="New Note" template="Template" # a template replaces content= obsidian create name="New Note" content="# Hello" open # also open in Obsidian obsidian append file="My Note" content="New line" obsidian rename path="folder/note.md" name="New name" obsidian move path="folder/note.md" to="archive/" obsidian delete path="folder/note.md" obsidian search query="search term" limit=10 obsidian daily:read obsidian daily:append content="- [ ] New task" obsidian property:set name="status" value="done" file="My Note" obsidian tasks daily todo obsidian ta
Preview of the first 4,000 characters. Read full instructions →
obsidian-headless4.41 KB
--- name: obsidian-headless description: Sync and publish Obsidian vaults from the command line with Obsidian Headless (`ob`), without the desktop app. Use when the user wants to set up or run Obsidian Sync or Obsidian Publish on a server, in CI, or from a terminal, or change a vault's Sync or Publish settings. --- # Obsidian Headless Use Obsidian Headless (`ob`) to run Obsidian Sync and Obsidian Publish from the command line. It doesn't need the desktop app, so it works on servers, in CI, and in sandboxes. It's in open beta. Docs: https://help.obsidian.md/headless `ob` only syncs and publishes files. To read or change notes without the app, edit the files directly and follow the obsidian-markdown skill. To control a running desktop app, use the obsidian-cli skill. ## Before using ob Check availability with `ob --help`. If it is missing, explain that Obsidian Headless requires Node.js 22 or later and offer installation with `npm install -g obsidian-headless`. Run `ob <command> --help` for a command's options. Sync and Publish each need an active subscription on the user's account. Most commands accept `--json` for machine-readable output. ## Log in `ob login` prints the account when already logged in. Otherwise it prompts for email, password, and a 2FA code, so ask the user to run it in their own terminal. Don't ask for their password or pass it with `--password`. `ob logout` clears the stored credentials. ## Vault paths Commands act on the vault in the current directory, or the one given with `--path`. Pass `--path` so the target is explicit. Before a command that changes remote state, confirm the vault, site, and path from list or status output. ## Sync Don't use the desktop app's Sync and Headless Sync for the same vault on the same device, because they cause conflicts. Ask the user to back up the vault folder before the first sync. ```bash ob sync-list-remote # remote vaults, including shared ones ob sync-list-local # vaults set up on this machine ob sync-setup --vault "Research" --path ~/vaults/research ob sync --path ~/vaults/research # sync once ob sync --path ~/vaults/research --continuous # keep syncing as files change ob sync-status --path ~/vaults/research ob sync-unlink --path ~/vaults/research # disconnect and remove stored credentials ``` `--vault` takes a remote vault's name or ID. For an end-to-end encrypted vault, `sync-setup` prompts for the encryption password, so let the user enter it. Set `--device-name` to label this machine in version history. `--continuous` runs until stopped, so start it in the background or as a service. `ob sync-create-remote --name "Research"` creates a remote vault. Add `--encryption e2ee` for end-to-end encryption or `--encryption standard` for managed encryption. ### Sync settings `ob sync-config --path <vault>` prints the vault's settings. Change them with: - `--mode bidirectional|pull-only|mirror-remote`. `pull-only` ignores local changes and `mirror-remote` reverts them, so confirm before setting either. - `--conflict-strategy merge|conflict` - `--excluded-folders "Archive,Templates"` - `--file-types image,audio,video,pdf,unsupported` for the attachment types to sync. - `--configs` for the settings categories to sync, e.g. `app,appearance,core-plugin`. - `--config-dir` when the vault's configuration folder isn't `.obsidian`. An empty string clears a list option, e.g. `--excluded-folders ""`. ## Publish ```bash ob publish-list-sites ob publish-setup --site my-notes --path ~/vaults/research ob publish --path ~/vaults/research --dry-run ob publish --path ~/vaults/research --yes ``` `ob publish` includes only notes with `publish: true` in their properties. `--all` includes every file, so use it only when the user asks. Run `--dry-run` first and show the user the changes. Without `--yes`, `ob publish` waits for confirmation, so pass `--yes` once the use
Preview of the first 4,000 characters. Read full instructions →
obsidian-markdown5.98 KB
--- name: obsidian-markdown description: Create and edit Obsidian Flavored Markdown with wikilinks, embeds, callouts, properties, and other Obsidian-specific syntax. Use when working with .md files in Obsidian, or when the user mentions wikilinks, callouts, frontmatter, tags, embeds, or Obsidian notes. --- # Obsidian Flavored Markdown Skill Create and edit valid Obsidian Flavored Markdown. Obsidian extends CommonMark and GFM with wikilinks, embeds, callouts, properties, comments, and other syntax. This skill covers only Obsidian-specific extensions -- standard Markdown (headings, bold, italic, lists, quotes, code blocks, tables) is assumed knowledge. ## Workflow: Creating an Obsidian Note 1. **Add frontmatter** with properties (title, tags, aliases) at the top of the file. See [PROPERTIES.md](references/PROPERTIES.md) for all property types. 2. **Write content** using standard Markdown for structure, plus Obsidian-specific syntax below. 3. **Link related notes** using wikilinks (`[[Note]]`) for internal vault connections, or standard Markdown links for external URLs. 4. **Embed content** from other notes, images, or PDFs using the `![[embed]]` syntax. See [EMBEDS.md](references/EMBEDS.md) for all embed types. 5. **Add callouts** for highlighted information using `> [!type]` syntax. See [CALLOUTS.md](references/CALLOUTS.md) for all callout types. 6. **Verify** the note renders correctly in Obsidian's reading view. > When choosing between wikilinks and Markdown links: use `[[wikilinks]]` for notes within the vault (Obsidian tracks renames automatically) and `[text](url)` for external URLs only. ## Internal Links (Wikilinks) ```markdown [[Note Name]] Link to note [[Note Name|Display Text]] Custom display text [[Note Name#Heading]] Link to heading [[Note Name#^block-id]] Link to block [[#Heading in same note]] Same-note heading link ``` Inside Markdown tables, escape wikilink alias pipes as `[[Note\|Alias]]` so the alias separator is not parsed as a table cell delimiter. When a table follows a paragraph, leave a blank line above it, or it renders as plain text. Links resolve by file name, not by the `aliases` property. A bare `[[Alias]]` stays unresolved; write `[[Note|Alias]]` to show an alias. Define a block ID by appending `^block-id` to any paragraph: ```markdown This paragraph can be linked to. ^my-block-id ``` For lists and quotes, place the block ID on a separate line after the block: ```markdown > A quote block ^quote-id ``` ## Embeds Prefix any wikilink with `!` to embed its content inline: ```markdown ![[Note Name]] Embed full note ![[Note Name#Heading]] Embed section ![[image.png]] Embed image ![[image.png|300]] Embed image with width ![[document.pdf#page=3]] Embed PDF page ``` See [EMBEDS.md](references/EMBEDS.md) for audio, video, search embeds, and external images. ## Callouts ```markdown > [!note] > Basic callout. > [!warning] Custom Title > Callout with a custom title. > [!faq]- Collapsed by default > Foldable callout (- collapsed, + expanded). ``` Common types: `note`, `tip`, `warning`, `info`, `example`, `quote`, `bug`, `danger`, `success`, `failure`, `question`, `abstract`, `todo`. See [CALLOUTS.md](references/CALLOUTS.md) for the full list with aliases, nesting, and custom CSS callouts. ## Properties (Frontmatter) ```yaml --- title: My Note date: 2024-01-15 tags: - project - active aliases: - Alternative Name cssclasses: - custom-class --- ``` Default properties: `tags` (searchable labels), `aliases` (alternative names offered in link suggestions; links still use the file name), `cssclasses` (CSS classes for styling). See [PROPERTIES.md](references/PROPERTIES.md) for all property types, tag syntax rules, and advanced usage. ## Tags ```markdown #tag Inline tag #nested/tag
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 3 — file references are metadata, not package contents.
Release notes
Adds an Obsidian Headless skill to sync and publish vaults without the desktop app, kanban views in Bases, and fixes for Bases display names and the CLI on WSL.
Declared in the saved package. Remote tools may change independently.
Package details
Publisher declarations from the archived package. These are separate from our research and the live service's terms.
- Package license
- MIT
- Package author
- Obsidian
- Keywords
- See keywords
- Declared availability
- No country restrictions declaredDeclared regions; live availability may differ.
- Commerce declaration
- Does not support commerceThis does not establish whether access is free or paid.
Package observed Nov 18, 2026.
Technical details
- First seen
- Nov 18, 2026 · 06:00 UTC
- Last seen
- Nov 18, 2026 · 06:00 UTC
- Collection status
- Collected
plugins_6aee4fde227881919d61b034b1c31096
Download plugin data (JSON)Plugin details: served from cache. Prepared . Refreshed when plugin data changes or after 6 hours. Your account and Follow status are live.