Skip to main content Home Creators jeremylongshore tons-of-skills-marketplace obsidian-cost-tuning
obsidian-cost-tuning Optimize Obsidian resource usage, sync storage, Publish hosting, and
third-party plugin API costs. Use when managing vault size, reducing
Sync bandwidth, controlling Publish costs, or optimizing external API
consumption from community plugins.
Trigger with phrases like "obsidian costs", "obsidian sync storage",
"optimize obsidian", "reduce obsidian costs", "obsidian publish costs".
Jump to install Skills Marketplace Discover and explore AI skills built by the community.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Show prompt details A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/jeremylongshore/tons-of-skills-marketplace --skill obsidian-cost-tuningThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Download Zip Downloading... More from this repository langchain-deploy-integration Deploy a LangChain 1.0 / LangGraph 1.0 app to Cloud Run, Vercel, or LangServe correctly โ with timeouts sized for chain length, cold-start mitigation, SSE anti-buffering headers, and Secret Manager over .env. Use when prepping a first production deploy, debugging a stream that hangs behind a proxy, or diagnosing p99 latency spikes. Trigger with "langchain deploy", "langchain cloud run", "langchain vercel python", "langchain langserve", or "langchain docker".
langchain-langgraph-agents Build a correct LangGraph 1.0 ReAct agent with create_react_agent โ typed tools, error propagation, recursion caps, and stop conditions that actually stop. Use when writing a first tool-calling agent, migrating from AgentExecutor or initialize_agent, or diagnosing an agent that loops on vague prompts. Trigger with "langgraph agent", "create_react_agent", "langgraph tool calling", "AgentExecutor migration", or "agent loop cost".
langchain-langgraph-human-in-loop Build LangGraph 1.0 human-in-the-loop approval flows with interrupt_before /
interrupt_after and Command(resume=...) โ JSON-serializable state, clean
resume semantics, and UI wiring for approval decisions. Use when adding an
approval gate before an expensive tool call, wiring a Slack/web UI for agent
approvals, or debugging a graph that crashes on interrupt.
Trigger with "langgraph human in loop", "langgraph interrupt_before",
"langgraph approval flow", "Command resume", "langgraph HITL".
name obsidian-cost-tuning description Optimize Obsidian resource usage, sync storage, Publish hosting, and
third-party plugin API costs. Use when managing vault size, reducing
Sync bandwidth, controlling Publish costs, or optimizing external API
consumption from community plugins.
Trigger with phrases like "obsidian costs", "obsidian sync storage",
"optimize obsidian", "reduce obsidian costs", "obsidian publish costs".
allowed-tools Read, Write, Edit, Bash(du:*), Bash(find:*), Grep version 1.13.0 license MIT author Jeremy Longshore <jeremy@intentsolutions.io> tags ["obsidian","cost-optimization","sync","publish","storage"] compatibility Designed for Claude Code
Obsidian Cost Tuning
Overview
Optimize costs across Obsidian's paid services and third-party plugin API usage. Covers Obsidian Sync storage management ($4-$10/mo), Publish hosting optimization ($8/mo per site), vault size reduction strategies, plugin API cost control with caching and quotas, and self-hosted alternatives for zero-cost sync.
Prerequisites
Understanding of your Obsidian subscription tier
Terminal access to the vault directory
Knowledge of which community plugins make external API calls
Cost Structure
Service Price Storage Cost Driver Obsidian (core) Free N/A None Catalyst (early access) $25 one-time N/A One-time Sync (Standard) $4/mo 1 GB Vault size, attachment count Sync (Plus) $8/mo 10 GB Large vaults with media Publish $8/mo per site N/A Published page count, bandwidth Plugin API costs Varies N/A Per-call pricing (AI, translation, etc.)
Instructions
Step 1: Audit Vault Size and Storage Usage
set -euo pipefail
VAULT_PATH="${1:-$HOME /MyVault} "
echo "=== Vault Storage Audit ==="
echo "Total vault size: $(du -sh "$VAULT_PATH " 2>/dev/null | cut -f1) "
echo ".obsidian size: $(du -sh "$VAULT_PATH /.obsidian" 2>/dev/null | cut -f1) "
echo ""
echo "=== Files by Type ==="
command
"$VAULT_PATH "
type
'*/.obsidian/*'
'*/.trash/*'
's/.*\.//'
sort
uniq
sort
head
echo
""
echo
"=== Top 20 Largest Files ==="
command
"$VAULT_PATH "
type
'*/.obsidian/*'
exec
du
sort
head
echo
""
echo
"=== Plugin Cache Sizes ==="
for
dir
in
"$VAULT_PATH /.obsidian/plugins"
do
"$dir /data.json"
continue
du
"$dir /data.json"
cut
echo
" $(basename "$dir " ) /data.json: $size "
done
Step 2: Reduce Sync Storage โ Exclusion Patterns Obsidian Sync respects .obsidian/sync-exclude.json for excluding paths:
{
"patterns" : [
"*.pdf" ,
"*.mp4" ,
"*.mov" ,
"*.zip" ,
"*.tar.gz" ,
"attachments/archives/**" ,
"node_modules/**" ,
".git/**"
]
}
For manual file-level control:
command find "$VAULT_PATH " -type f -size +5M -not -path '*/.obsidian/*' \
-exec du -h {} + | sort -rh
echo "PDF count: $(command find "$VAULT_PATH " -name '*.pdf' | wc -l) "
echo "Image count: $(command find "$VAULT_PATH " \( -name '*.png' -o -name '*.jpg' -o -name '*.jpeg' \) | wc -l) "
echo "Total attachments: $(du -sh "$VAULT_PATH /attachments" 2>/dev/null | cut -f1) "
Strategies to stay under the 1 GB Sync Standard tier:
Move PDFs to a local folder outside the vault, link with ` URIs
Compress images before adding: pngquant --quality=65-80 *.png or ImageOptim
Use external image hosting (Cloudinary free tier: 25 credits/mo, ~25K transforms)
Exclude .obsidian/plugins/*/data.json โ plugin caches regenerate on launch
Step 3: Optimize Plugin API Costs Plugins that call external APIs (AI assistants, translation, image generation) can incur per-call costs. Implement caching in your plugin:
import { Plugin } from 'obsidian' ;
interface CacheEntry <T> {
result : T;
timestamp : number ;
}
export class APICache <T> {
private cache = new Map <string , CacheEntry <T>>();
private ttlMs : number ;
constructor (ttlMinutes : number = 60 this .ttlMs = ttlMinutes * 60 * 1000 ;
}
get (key : string ): T | null {
const entry = this .cache .get (key);
if (!entry) return null ;
if (Date .now () - entry.timestamp > this .ttlMs ) {
this .cache .delete (key);
return null ;
}
return entry.result ;
}
set (key : string , result : Tthis .cache .set (key, { result, timestamp : Date .now () });
if (this .cache .size > 1000 ) {
const oldest = this .cache .keys ().next ().value ;
if (oldest) this .cache .delete (oldest);
}
}
async getOrFetch (key : string , fetchFn : () => Promise <T>): Promise <T> {
const cached = this .get (key);
if (cached !== null ) return cached;
const result = await fetchFn ();
this .set (key, result);
return result;
}
clear (this .cache .clear (); }
get size () { return this .cache .size ; }
}
const aiCache = new APICache <string >(24 * 60 );
async function getSummary (noteContent : string Promise <string > {
const hash = simpleHash (noteContent);
return aiCache.getOrFetch (hash, async () => {
const response = await requestUrl ({ url : 'https://api.openai.com/...' , ... });
return response.json .choices [0 ].message .content ;
});
}
Step 4: Rate Limiting for External Calls
class APIQuota {
private calls = 0 ;
private resetTime = 0 ;
private maxCallsPerHour : number ;
constructor (maxPerHour : number this .maxCallsPerHour = maxPerHour;
}
canCall (): boolean {
const now = Date .now ();
if (now - this .resetTime > 3600000 ) {
this .calls = 0 ;
this .resetTime = now;
}
return this .calls < this .maxCallsPerHour ;
}
recordCall (this .calls ++; }
remaining (): number {
return Math .max (0 , this .maxCallsPerHour - this .calls );
}
}
const quota = new APIQuota (100 );
async function callExternalAPI (if (!quota.canCall ()) {
new Notice ('API quota exceeded. Try again later.' );
return ;
}
quota.recordCall ();
}
Step 5: Optimize Obsidian Publish Costs Publish at $8/mo per site. Minimize what you publish to reduce bandwidth:
---
publish: true
permalink: custom-url
---
Cost reduction strategies:
Use publish: true frontmatter selectively instead of publishing entire folders
Compress images before embedding (target < 200KB per image)
Use lazy-loading for heavy media: !alt with external hosting
Monitor page count โ each additional page adds build time and bandwidth
Use Obsidian's built-in image compression in Publish settings
Step 6: Self-Hosted Sync Alternatives (Free)
obsidian_git:
cost: Free
setup: Install Obsidian Git plugin, configure repo
pros: Full version history, unlimited storage, branch per device
cons: Manual setup, no conflict resolution UI, requires Git knowledge
best_for: Developers, technical users
syncthing:
cost: Free
setup: Install on each device, share vault folder
pros: Real-time sync, no cloud dependency, encrypted
cons: Devices must be online simultaneously (or have relay), no web access
best_for: Privacy-focused users, LAN-only setups
icloud_drive:
cost: Free (with Apple devices)
setup: Move vault to ~/Library/Mobile Documents/iCloud~md~obsidian/Documents/
pros: Zero config on Apple ecosystem, transparent to Obsidian
cons: .obsidian/ conflicts common, slow on large vaults, Apple-only
best_for: Apple-only users with small vaults
remotely_save:
cost: Free (with existing S3/WebDAV)
setup: Install Remotely Save plugin, configure backend
pros: Works with S3, Dropbox, OneDrive, WebDAV
cons: Plugin manages sync (no native integration), manual conflict handling
best_for: Users with existing cloud storage
Step 7: Ongoing Cost Monitoring Script #!/bin/bash
VAULT="${1:-$HOME /MyVault} "
echo "=== Monthly Cost Estimate ==="
SIZE_MB=$(du -sm "$VAULT " 2>/dev/null | cut -f1)
echo "Vault size: ${SIZE_MB} MB"
if [ "$SIZE_MB " -lt 1024 ]; then
echo "Sync tier needed: Standard ($4 /mo) โ under 1 GB"
elif [ "$SIZE_MB " -lt 10240 ]; then
echo "Sync tier needed: Plus ($8 /mo) โ under 10 GB"
else
echo "WARNING: Vault exceeds 10 GB โ Sync Plus limit"
fi
PUB_COUNT=$(grep -rl 'publish: true' "$VAULT " /*.md "$VAULT " /**/*.md 2>/dev/null | wc -l)
echo "Published pages: $PUB_COUNT "
[ "$PUB_COUNT " -gt 0 ] && echo "Publish cost: \$8/mo" || echo "Publish cost: \$0"
echo ""
echo "=== Plugins with potential API costs ==="
for dir in "$VAULT /.obsidian/plugins" /*/; do
manifest="$dir /manifest.json"
[ -f "$manifest " ] || continue
name=$(python3 -c "import json; print(json.load(open('$manifest ')).get('name','?'))" 2>/dev/null)
if grep -q 'requestUrl\|fetch(' "$dir /main.js" 2>/dev/null; then
echo " $name โ makes network requests"
fi
done
Output
Vault storage audit with file type breakdown and largest files
Sync exclusion patterns reducing bandwidth consumption
API response cache with TTL and bounded size
Rate limiter preventing runaway API costs
Publish optimization with selective frontmatter and image compression
Self-hosted sync comparison (Git, Syncthing, iCloud, Remotely Save)
Monthly cost estimation script
Error Handling Issue Cause Solution Sync storage full Large binary attachments Exclude PDFs/videos from sync, compress images Plugin API costs spike No caching or rate limiting Implement APICache + APIQuota (Steps 3-4) Vault backup too large Accumulated .trash and plugin caches Empty .trash/, exclude plugins/*/data.json from sync Publish site slow Large uncompressed images Compress to < 200KB, use external image CDN Git sync conflicts on .obsidian/ Multiple devices editing config Add workspace.json to .gitignore iCloud sync corruption Simultaneous edits on two Apple devices Never edit same note on two devices at once
Examples
Quick Storage Savings
command find "$VAULT_PATH " -name '*.png' -exec pngquant --quality=65-80 --skip-if-larger --ext .png --force {} \;
mkdir -p ~/VaultArchive
command find "$VAULT_PATH " -name '*.pdf' -size +10M -exec mv {} ~/VaultArchive/ \;
Persistent API Cache Across Sessions
async onload (const data = await this .loadData ();
if (data?.apiCache ) this .apiCache .restore (data.apiCache );
}
onunload (this .saveData ({ ...this .settings , apiCache : this .apiCache .serialize () });
}
Resources
Next Steps For performance optimization, see obsidian-performance-tuning.
For data backup and recovery patterns, see obsidian-data-handling.
