Joplin — User Guide

Joplin is a free, open-source note-taking and to-do application with end-to-end encryption, cross-device synchronization, and Markdown-native editing. It runs on desktop (Windows, macOS, Linux), mobile (Android, iOS), the terminal (CLI), and extends into the browser via the Web Clipper extension. Notes are stored locally in Markdown format and can be synchronized across devices through Joplin Cloud, Joplin Server, Nextcloud, WebDAV, OneDrive, Dropbox, Amazon S3, or a local filesystem.

This guide covers every user-facing feature — from first install through advanced workflows — written from the Joplin source code.

1. Quick Start

Get up and running in under five minutes.

1.1 Install

Download the latest release for your platform:

1.2 Create Your First Note

1. Launch Joplin.
2. Click the New Note button (or press Ctrl+N / Cmd+N).
3. Type a title and start writing in Markdown.
4. Your note saves automatically.

1.3 Create Your First Notebook

1. Click New Notebook in the sidebar (or press Ctrl+Shift+B).
2. Name it (e.g., "Work", "Personal", "Projects").
3. Drag existing notes into the notebook, or create new ones inside it.

1.4 Set Up Sync

1. Open Tools → Options → Synchronisation (desktop) or Settings → Sync (mobile).
2. Choose a sync target (Joplin Cloud is the simplest).
3. Enter your credentials and click Apply.
4. Press Synchronise (or wait for auto-sync).

Tip

Start with Joplin Cloud if you want zero-config sync. It handles encryption key management, sharing, and publishing out of the box. You can always switch to a self-hosted target later — your notes stay in open Markdown format regardless.

1.5 Install the Web Clipper

1. Install the browser extension from the Chrome Web Store or Firefox Add-ons.
2. Open Joplin desktop — the clipper connects automatically via the local REST API.
3. Navigate to any web page, click the Joplin icon, and choose Clip simplified page, Clip complete page, Clip selection, Clip screenshot, or Clip URL.

1.6 Enable Encryption

1. Open Tools → Options → Encryption.
2. Click Enable encryption and set a master password.
3. All devices using the same sync target will prompt for this password on next sync.

Tip

Write down your master password and store it somewhere safe. If you lose it and have no decrypted device, your encrypted notes cannot be recovered.

2. Installation

2.1 Desktop (Electron)

Windows

Installer (recommended):

# Download from joplinapp.org and run the .exe installer
# Or use winget:
winget install Joplin.Joplin

Portable mode: When Joplin detects the PORTABLE_EXECUTABLE_FILE environment variable (set automatically when running from certain portable launchers), it stores all data next to the executable instead of in the user profile directory.

Default data directory: %APPDATA%\Joplin

Important

On Windows, the installer requires administrator privileges. If you cannot elevate, use the portable .zip release instead.

macOS

# Homebrew
brew install --cask joplin

# Or download the .dmg from joplinapp.org

Default data directory: ~/.config/joplin-desktop

Linux

AppImage (recommended):

wget -O - https://raw.githubusercontent.com/laurent22/joplin/dev/Joplin_install_and_update.sh | bash

This installs the AppImage to ~/.joplin/ and creates a desktop entry.

Default data directory: ~/.config/joplin-desktop

When running as an AppImage, the APPIMAGE environment variable is set automatically, enabling portable detection logic.

Warning

The AppImage requires FUSE to run. On Ubuntu 22.04+, install it with sudo apt install libfuse2. Without FUSE, the AppImage will fail to launch with a cryptic error.

2.2 Mobile

Android

• Google Play Store: Search "Joplin" by Laurent Cozic.
• F-Droid: Available in the default repository.

Data is stored in the app's internal storage. Notes sync via the configured sync target.

iOS

• App Store: Search "Joplin" by Laurent Cozic.

Data is stored in the app sandbox. iCloud is not used for sync — configure a sync target in Settings.

2.3 CLI (Terminal)

# Install globally via npm
npm install -g joplin

# Launch the terminal UI
joplin

# Or run a single command
joplin help

Requirements: Node.js 18+, npm.

Default data directory: ~/.config/joplin (Linux/macOS), %APPDATA%\Joplin (Windows).

The CLI provides a full terminal user interface (TUI) built on terminal-kit, with a note list, editor pane, and notebook sidebar. It also supports non-interactive single-command execution for scripting.

2.4 Web Clipper (Browser Extension)

The Web Clipper is a companion browser extension that communicates with the Joplin desktop application via its local REST API (port 41184 by default).

Installation:

1. Install the extension from Chrome Web Store or Firefox Add-ons.
2. Ensure Joplin desktop is running with the Web Clipper service enabled (Tools → Options → Web Clipper → Enable Web Clipper Service).
3. The extension auto-detects the running Joplin instance.

Clipping modes:

2.5 Building from Source

git clone https://github.com/laurent22/joplin.git
cd joplin

# Install dependencies
yarn install

# Build all packages
yarn build

# Run desktop app in development mode
cd packages/app-desktop
yarn start

The monorepo uses Yarn workspaces. Key packages:

2.6 Updating

• Desktop: Auto-update checks on launch (Windows/macOS). Linux AppImage: re-run the install script.
• Mobile: Standard app store updates.
• CLI: npm update -g joplin

Important

After a major version update, run a full sync before making changes on other devices. Database migrations may alter the sync format.

3. Configuration

3.1 General Settings

Access settings via Tools → Options (desktop), Settings gear icon (mobile), or the config CLI command.

Language & Locale

The locale auto-detects from the system LANG environment variable on first launch.

Note Display

3.2 Themes

Joplin ships with 8 built-in themes:

Theme settings:

To enable automatic theme switching based on your operating system's light/dark mode:

1. Set themeAutoDetect to enabled.
2. Choose your preferredLightTheme (e.g., Light or Solarised Light).
3. Choose your preferredDarkTheme (e.g., Dark, OLED Dark, or Nord).

3.3 Editor Settings

Joplin's desktop editor supports two modes: a Markdown code editor (CodeMirror-based) and a Rich Text / WYSIWYG editor (TinyMCE-based).

Editor layout modes:

The layoutButtonSequence setting controls which editor layout buttons appear in the toolbar. Available layouts:

Toggle between layouts using the toolbar buttons or the keyboard shortcut Ctrl+L.

3.4 Synchronisation Settings

Resource download modes explained:

• Always: All attachments download immediately during sync. Uses more bandwidth and storage but ensures offline access.
• Manual: Attachments download only when you click on them. Saves bandwidth on metered connections.
• Auto: Joplin decides based on file size and available resources. A balanced default for most users.

3.5 Sync Target Setup

Joplin Cloud (Target 10)

The simplest option — managed hosting by the Joplin team.

1. Create an account at joplincloud.com.
2. In Joplin: Tools → Options → Synchronisation.
3. Set Synchronisation target to Joplin Cloud.
4. The path defaults to api.joplincloud.com.
5. Enter your Joplin Cloud email and password.
6. Click Check synchronisation configuration to verify.

Benefits: managed encryption, note sharing, note publishing, email-to-note.

Joplin Server (Target 9) — Self-Hosted

For users who want full control with Joplin-specific features (sharing, publishing).

# docker-compose.yml for Joplin Server
version: '3'
services:
  joplin-server:
    image: joplin/server:latest
    ports:
      - "22300:22300"
    environment:
      - APP_BASE_URL=https://joplin.yourdomain.com
      - APP_PORT=22300
      - DB_CLIENT=pg
      - POSTGRES_PASSWORD=changeme
      - POSTGRES_DATABASE=joplin
      - POSTGRES_USER=joplin
      - POSTGRES_PORT=5432
      - POSTGRES_HOST=db
    depends_on:
      - db
  db:
    image: postgres:16
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=changeme
      - POSTGRES_USER=joplin
      - POSTGRES_DB=joplin

Configuration in Joplin:

Nextcloud (Target 5)

Sync target:  Nextcloud
WebDAV URL:   https://your-nextcloud.com/remote.php/webdav/Joplin
Username:     your-nextcloud-user
Password:     your-nextcloud-password (or app password)

Create the Joplin directory in your Nextcloud first via the Nextcloud web interface or WebDAV.

WebDAV (Target 6)

Any WebDAV-compatible server works.

Compatible services include Apache mod_dav, Nginx with ngx_http_dav_module, Synology NAS, and any standards-compliant WebDAV implementation.

OneDrive (Target 3)

1. Set sync target to OneDrive.
2. Click Authorise — a browser window opens for Microsoft OAuth.
3. Sign in with your Microsoft account and grant permissions.
4. Joplin stores the auth token in sync.3.auth.
5. Notes sync to Apps/Joplin in your OneDrive.

No manual URL or credential entry required. The OAuth flow handles everything.

Dropbox (Target 7)

1. Set sync target to Dropbox.
2. Click Authorise — a browser window opens for Dropbox OAuth.
3. Sign in and grant permissions.
4. Joplin stores the auth token in sync.7.auth.
5. Notes sync to Apps/Joplin in your Dropbox.

Amazon S3 (Target 8)

For users with AWS infrastructure or S3-compatible storage (MinIO, Wasabi, Backblaze B2).

For S3-compatible providers (MinIO, Wasabi):

S3 URL:           https://s3.wasabisys.com  (Wasabi example)
Force path style: Enabled
Region:           us-east-1

Filesystem (Target 2)

Sync to a local directory — useful for USB drives, network shares, or manual backup.

The directory must exist and be writable. Joplin creates its own internal structure inside it.

3.6 OCR Settings (Desktop Only)

Optical Character Recognition extracts searchable text from image attachments and PDFs.

To enable OCR:

1. Go to Tools → Options → General.
2. Enable OCR.
3. Wait for existing attachments to process (progress shown in note panel).
4. New attachments are processed automatically.

3.7 Proxy Settings

Joplin respects standard proxy environment variables for all network operations including sync:

Set these before launching Joplin:

export https_proxy=http://proxy.example.com:8080
joplin

On desktop, you can also configure proxy settings in the application preferences.

3.8 CLI Configuration

The CLI config command manages all settings from the terminal:

# View a setting
joplin config sync.target

# Set a value
joplin config sync.target 9
joplin config sync.9.path https://joplin.example.com
joplin config sync.9.username [email removed]

# List all settings
joplin config

# Reset a setting to default
joplin config locale --reset

4. Core Usage

4.1 Notes

Creating Notes

• Desktop: Ctrl+N (Windows/Linux) or Cmd+N (macOS), or click New Note in the toolbar.
• Mobile: Tap the + button.
• CLI: joplin mknote "My Note Title"

Editing Notes

Notes are written in GitHub-flavoured Markdown with extensions:

Standard Markdown:

# Heading 1
## Heading 2
### Heading 3

**Bold text**
*Italic text*
~~Strikethrough~~

- Bullet list
- Second item
  - Nested item

1. Numbered list
2. Second item

[Link text](https://example.com)
![Image alt](:/resource_id)

> Blockquote

`inline code`

Fenced code blocks with syntax highlighting:

```python
def hello():
    print("Hello, Joplin!")
```

Tables:

| Column 1 | Column 2 |
|----------|----------|
| Cell 1   | Cell 2   |

Joplin-specific Markdown extensions:

Rich Text (WYSIWYG) Editor

Toggle between Markdown and Rich Text mode via View → Toggle editor layout or Ctrl+L.

The Rich Text editor provides familiar word-processor controls:

• Bold, italic, underline, strikethrough formatting buttons
• Heading level dropdown
• Bullet and numbered list buttons
• Insert table, horizontal rule, link, image
• Code block insertion
• Text alignment

When editor.enableTextPatterns is on, typing Markdown syntax in the Rich Text editor auto-formats it (e.g., **text** becomes bold text).

Tip

If you prefer a word-processor experience, switch to Rich Text mode and enable text patterns. You get auto-formatting of Markdown syntax with a visual editing surface — the best of both worlds.

Note Properties

Each note has metadata accessible via the note info panel (click the i icon or Note → Properties):

Note Sorting

Notes can be sorted by any of these fields:

Set the sort order in View → Sort notes by or via joplin config notes.sortOrder.field title in the CLI.

4.2 Notebooks

Notebooks are the primary organisational unit. They can be nested to any depth.

Creating Notebooks

• Desktop: Ctrl+Shift+B or File → New Notebook
• Mobile: Tap the sidebar → New Notebook
• CLI: joplin mkbook "Notebook Name"

Nested Notebooks

Drag a notebook onto another notebook to create a sub-notebook. The tree structure is unlimited in depth.

In the CLI, use joplin use "Parent/Child" to navigate to a nested notebook.

Notebook Sorting

4.3 To-Dos

To-dos are notes with a checkbox. They appear with a checkbox icon in the note list and can have due dates and alarms.

Creating To-Dos

• Desktop: Click the New To-Do button (checkbox icon) or File → New To-Do
• CLI: joplin mktodo "Buy groceries"

Managing To-Dos

• Mark complete: Click the checkbox in the note list, or use joplin done "Buy groceries" (CLI).
• Mark incomplete: Click the checkbox again, or use joplin undone "Buy groceries" (CLI).
• Set due date: Open the note, click the alarm icon, set date/time.
• Set alarm: Due date reminders trigger desktop notifications.

To-Do Display Settings

4.4 Tags

Tags provide cross-notebook organisation. A note can have unlimited tags, and tags work across all notebooks.

Managing Tags

• Desktop: Click the tag icon on a note, type a tag name, press Enter.
• CLI:

# Add a tag to a note
joplin tag add "important" "My Note Title"

# Remove a tag from a note
joplin tag remove "important" "My Note Title"

# List all tags
joplin tag list

# List notes with a specific tag
joplin tag notetags "important"

Tags are shown in the sidebar. Click a tag to filter notes across all notebooks.

4.5 Search

Desktop Search

Press Ctrl+F (note search) or Ctrl+G / F6 (global search) to search across all notes.

Search syntax:

Combine operators freely:

tag:work title:budget -tag:archive type:note created:20260101

This finds regular notes (not to-dos) tagged "work" with "budget" in the title, not tagged "archive", created in 2026 or later.

CLI Search

joplin search "query text"

The CLI search command supports the same search syntax as the desktop.

OCR Search

When OCR is enabled (ocr.enabled and ocr.searchInExtractedContent), search results include text extracted from:

• Image attachments (PNG, JPEG, etc.)
• PDF documents
• Scanned documents

This means you can search for text visible in photos, screenshots, or scanned papers.

4.6 Attachments & Resources

Adding Attachments

• Drag and drop: Drop files onto the editor.
• Menu: Edit → Attach file or click the paperclip icon.
• CLI: joplin attach <note> <file>
• Paste: Paste images directly from clipboard (Ctrl+V).

Supported formats include images (PNG, JPEG, GIF, SVG, WebP), documents (PDF, DOCX, XLSX), audio, video, and any other file type.

Attachment Storage

Attachments (called "resources" internally) are stored locally and synced alongside notes. They are referenced in Markdown via Joplin's resource ID syntax:

![Image description](:/abc123def456)
[Document.pdf](:/abc123def456)

Resource Download Modes

Control how attachments sync with sync.resourceDownloadMode:

4.7 Geolocation

Joplin can record the geographic location where a note was created (with your permission).

• Mobile: Uses device GPS.
• Desktop: Uses IP-based geolocation.
• CLI: Use joplin geoloc <note> to set or view geolocation.

Click the geolocation link in note properties to open the location in your default maps application.

4.8 Note History

Joplin keeps a version history of your notes. Access it via Note → History or the history icon.

Previous versions show a diff view highlighting what changed. You can restore any previous version, which creates a new revision (the current version is preserved in history).

4.9 External Editor

Desktop

Click the external editor button (pencil-with-arrow icon) or use Ctrl+E to open the current note in your system's default text editor or a configured external editor.

Changes saved in the external editor are reflected in Joplin immediately (file watch).

CLI

The CLI edit command opens a note in your $EDITOR:

# Set your preferred editor
export EDITOR=vim

# Edit a note
joplin edit "My Note Title"

The EDITOR environment variable determines which editor launches. Common values: vim, nano, code --wait, subl --wait.

4.10 CLI Command Reference

The CLI provides 42 commands, each accessible as joplin <command>:

Use joplin help <command> for detailed usage of any command.

5. Common Tasks

5.1 Migrating from Evernote

Joplin has first-class Evernote import support via the ENEX format.

1. In Evernote, select the notebook(s) to export.
2. Choose File → Export Notes → ENEX format.
3. In Joplin, go to File → Import → ENEX - Evernote Export File.
4. Select the .enex file.
5. Choose a target notebook (or let Joplin create one matching the Evernote notebook name).

What transfers:

For large Evernote libraries, export one notebook at a time to avoid memory issues.

CLI import:

joplin import /path/to/export.enex

5.2 Migrating from OneNote

Joplin includes a OneNote importer that converts .onepkg files using a Rust-based WASM converter.

1. Export notebooks from OneNote as .onepkg files.
2. In Joplin: File → Import → OneNote Export File.
3. Select the file and wait for conversion.

Warning

The OneNote importer is computationally intensive. Large notebooks may take significant time to process, and the import process may appear to hang during the postprocessing stage (known issue #15132). Allow ample time and do not interrupt the process.

5.3 Importing Markdown Files

# Import a single Markdown file
joplin import /path/to/notes/file.md

# Import a directory of Markdown files (desktop: File → Import → Markdown directory)
joplin import /path/to/markdown/directory/

Each .md file becomes a note. Sub-directories become sub-notebooks.

5.4 Importing JEX (Joplin Export)

JEX files are Joplin's native export format — they preserve everything including encryption, attachments, and note IDs.

1. File → Import → JEX - Joplin Export File.
2. Select the .jex file.

CLI: joplin import /path/to/export.jex

5.5 Exporting Notes

JEX (Joplin Export) — Recommended for Backup

File → Export all → JEX - Joplin Export File

Exports everything: notes, notebooks, tags, resources, metadata. This is the recommended backup format.

Markdown

File → Export all → Markdown

Exports notes as .md files with attachments in _resources/ directories. Notebook structure is preserved as a directory hierarchy.

HTML

File → Export all → HTML File

Exports rendered HTML versions of notes.

CLI export:

# Export all notes
joplin export /path/to/output --format jex

# Export a specific notebook
joplin export /path/to/output --format md --notebook "Work"

5.6 Setting Up End-to-End Encryption (E2EE)

E2EE ensures that your notes are encrypted before leaving your device. Only devices with the master password can decrypt them.

Enable E2EE:

1. Go to Tools → Options → Encryption.
2. Click Enable encryption.
3. Enter a strong master password.
4. Click OK.
5. Sync immediately to propagate the encryption configuration.

On additional devices:

1. Sync the device.
2. Joplin will detect that encryption is enabled.
3. Enter the master password when prompted.
4. Notes decrypt automatically.

Key management:

• Master keys encrypt/decrypt notes. Created automatically.
• Public-private key pairs (PPK) are used for sharing encrypted notes between users (Joplin Cloud/Server only).

CLI E2EE:

# Enable encryption
joplin e2ee enable

# Decrypt all notes (disable E2EE)
joplin e2ee disable

# Show E2EE status
joplin status

Caution

If you lose your master password and have no device with decrypted notes, your encrypted notes are permanently lost. There is no recovery mechanism. Store your master password securely — ideally in a separate password manager.

5.7 Sharing Notes (Joplin Cloud / Joplin Server)

Sharing requires Joplin Cloud or Joplin Server. Share individual notes or entire notebooks with other users.

Share a notebook:

1. Right-click a notebook → Share notebook.
2. Enter the recipient's email (must have a Joplin Cloud/Server account).
3. Choose permission level: Can view or Can edit.

Share a note by link (publish):

1. Right-click a note → Publish note.
2. A public URL is generated.
3. Anyone with the link can view the rendered note (read-only).

CLI publishing:

# Publish a note
joplin publish "My Note Title"

# Unpublish a note
joplin unpublish "My Note Title"

# Share a notebook (Joplin Cloud/Server only)
joplin share "Notebook Name" [email removed]

5.8 Using the Web Clipper Effectively

Clip a simplified article:

1. Navigate to an article.
2. Click the Joplin Clipper icon.
3. Select Clip simplified page.
4. Choose the destination notebook.
5. Optionally add tags.
6. Click Confirm.

Clip a selection:

1. Select text/images on a page.
2. Click the Joplin Clipper icon.
3. Select Clip selection.

Clip multiple pages into one note:

Use the Clip URL mode repeatedly — each clip creates a separate note that you can later merge.

Keyboard shortcut: Configure a browser keyboard shortcut for quick clipping (browser extension settings).

5.9 Working with To-Do Lists

Create a project task list:

1. Create a new to-do: File → New To-Do.
2. Title it with the project name.
3. In the body, use Markdown checkboxes for sub-tasks:

## Sprint 14 Tasks
- [ ] Design database schema
- [ ] Implement API endpoints
- [x] Set up CI/CD pipeline
- [ ] Write integration tests

4. Set a due date via the alarm icon.
5. Tag with project tags.
6. Sort the note list by todo_due to see upcoming deadlines.

5.10 Creating Templates

Joplin supports note templates for frequently used note structures.

1. Create a note with your template content.
2. Save it in a "Templates" notebook.
3. When you need it, use File → New note from template and select the template.

Templates support variables:

5.11 Using Keyboard Shortcuts

Global shortcuts (desktop):

Customise shortcuts via Tools → Options → Keyboard Shortcuts or the CLI keymap command.

5.12 Using Internal Links

Link between notes using their unique ID:

1. Right-click a note in the note list → Copy Markdown link.
2. Paste the link in another note.
3. Clicking the link opens the target note.

The Markdown syntax is:

[Note Title](:/{note_id})

Links survive note renames because they reference the immutable note ID.

5.13 Using Markdown Plugins and Math

KaTeX Math:

Inline: $E = mc^2$

Block:
$$
\int_{0}^{\infty} e^{-x^2} dx = \frac{\sqrt{\pi}}{2}
$$

Mermaid Diagrams:

```mermaid
graph TD
    A[Start] --> B{Decision}
    B -->|Yes| C[Action 1]
    B -->|No| D[Action 2]
```

5.14 Batch Operations (CLI)

The CLI batch command runs operations across multiple notes.

Copy notes between notebooks:

joplin cp "Note Title" "Destination Notebook"

Move notes:

joplin mv "Note Title" "Destination Notebook"

Rename notes:

joplin ren "Old Title" "New Title"

Delete notes and notebooks:

# Delete a note
joplin rmnote "Note Title"

# Delete a notebook (and all notes inside)
joplin rmbook "Notebook Name"

5.15 Using the REST API (Plugins & Automation)

Joplin desktop exposes a local REST API (default port 41184) used by plugins and the Web Clipper.

Enable the API:

1. Go to Tools → Options → Web Clipper.
2. Enable Web Clipper Service.
3. Note the API token shown.

Example API calls:

# List all notes
curl http://localhost:41184/notes?token=YOUR_TOKEN

# Get a specific note
curl http://localhost:41184/notes/NOTE_ID?token=YOUR_TOKEN&fields=id,title,body

# Create a note
curl -X POST http://localhost:41184/notes?token=YOUR_TOKEN \
  -H "Content-Type: application/json" \
  -d '{"title": "API Note", "body": "Created via API"}'

# Search notes
curl "http://localhost:41184/search?query=my+search&token=YOUR_TOKEN"

# List folders
curl http://localhost:41184/folders?token=YOUR_TOKEN

# List tags
curl http://localhost:41184/tags?token=YOUR_TOKEN

# Get resources (attachments)
curl http://localhost:41184/resources?token=YOUR_TOKEN

# Create a tag
curl -X POST http://localhost:41184/tags?token=YOUR_TOKEN \
  -H "Content-Type: application/json" \
  -d '{"title": "my-tag"}'

# Attach a tag to a note
curl -X POST http://localhost:41184/tags/TAG_ID/notes?token=YOUR_TOKEN \
  -H "Content-Type: application/json" \
  -d '{"id": "NOTE_ID"}'

Plugin API objects:

5.16 Organizing Large Note Collections

Notebook hierarchy strategy:

Work
  Projects
    Project Alpha
    Project Beta
  Meetings
    2026 Q1
    2026 Q2
  Reference
Personal
  Journal
  Recipes
  Travel
Archive

Tag taxonomy:

Use a consistent tag scheme:

• Status tags: active, done, blocked, review
• Priority tags: p1-critical, p2-high, p3-normal
• Context tags: @home, @office, @errands
• Project tags: project-alpha, project-beta

Combine search with tags and notebooks:

notebook:Work tag:active title:standup

5.17 Using Note Alarms and Reminders

1. Open a to-do note.
2. Click the alarm/bell icon.
3. Set the date and time.
4. Joplin will display a desktop notification at the scheduled time.

Alarms require the desktop app to be running. Mobile notifications depend on the mobile app's background process.

5.18 Custom CSS Styling

Customize the rendered note appearance with custom CSS:

1. Go to Tools → Options → Appearance → Custom stylesheet for rendered Markdown.
2. Click Edit to open the file (typically userstyle.css).
3. Add CSS rules.
4. Restart Joplin for changes to take effect.

Example custom CSS:

/* Increase base font size */
body {
    font-size: 16px;
    line-height: 1.6;
}

/* Custom heading colors */
h1 { color: #2c3e50; }
h2 { color: #34495e; }

/* Code block styling */
pre code {
    font-family: 'JetBrains Mono', monospace;
    font-size: 14px;
}

/* Table styling */
table {
    border-collapse: collapse;
    width: 100%;
}

th {
    background-color: #3498db;
    color: white;
}

You can also customize the editor appearance with a separate stylesheet for the editor panel.

5.19 Backup Strategies

JEX backup (recommended):

# Full backup via CLI
joplin export /backup/joplin-$(date +%Y%m%d).jex --format jex

Filesystem sync as backup:

Configure filesystem sync (Target 2) to a second location as a backup of your primary sync target:

1. Primary sync: Joplin Cloud.
2. Secondary: Filesystem to an external/cloud-synced drive.

Database backup:

The Joplin database is SQLite. On desktop, copy:

• Linux/macOS: ~/.config/joplin-desktop/database.sqlite
• Windows: %APPDATA%\Joplin\database.sqlite

Warning

Do not copy the SQLite database while Joplin is running — you may get a corrupted backup. Close Joplin first, or use the JEX export which handles locking correctly.

5.20 Note Printing and PDF Export

Print a note:

1. Open the note.
2. File → Print or Ctrl+P.
3. Choose your printer or "Save as PDF".

Export to PDF:

1. File → Export PDF.
2. Choose the output file.

The PDF reflects the rendered Markdown view, including images and formatting.

5.21 Multi-Window Mode (Desktop)

Open multiple notes in separate windows:

1. Right-click a note → Open in new window.
2. Each window is independent, with its own editor.

Important

There is a known issue (#15106) where note focus may behave unexpectedly when multiple windows are open. If you experience focus problems, close extra windows and try again.

5.22 Setting Up Plugins

Joplin's plugin system extends functionality with JavaScript/TypeScript plugins.

Installing plugins:

1. Go to Tools → Options → Plugins.
2. Browse the plugin directory or search by name.
3. Click Install.
4. Restart Joplin.

Popular plugin categories:

Plugin specifications:

• Plugins are JavaScript bundles with a manifest.json.
• Plugin IDs must be 16-256 characters, starting and ending with a letter or number.
• Plugins access the Joplin API through JoplinData (note/folder/tag CRUD) and JoplinImaging (image manipulation).
• Plugins can register content scripts, custom dialogs, menu items, and CodeMirror editor extensions.

5.23 Using Content Scripts

Content scripts are plugin-provided scripts that run within the note viewer or editor:

• Markdown-it plugins: Extend Markdown rendering (custom syntax, diagrams).
• CodeMirror plugins: Extend the code editor (custom commands, key bindings).

5.24 Working with Large Attachments

Attachment size considerations:

• Large files (videos, archives) sync fine but increase sync time.
• Use sync.resourceDownloadMode: manual on devices with limited storage.
• S3 sync targets handle large attachments best due to chunked uploads.

Optimizing images:

• Joplin does not resize images on import — resize before attaching if size is a concern.
• OCR processing time increases with image resolution.

5.25 Using Joplin on Multiple Devices

Recommended workflow:

1. Set up the same sync target on all devices.
2. If using E2EE, enter the master password on each device.
3. Let each device complete a full initial sync before making edits.
4. Avoid editing the same note simultaneously on two devices — conflict notes may be created.

Conflict resolution:

When two devices edit the same note offline:

• Joplin keeps both versions.
• A "Conflicts" notebook appears with the alternate version.
• Manually merge the two versions and delete the conflict note.

5.26 Using the CLI as a Daily Driver

The CLI offers a complete TUI experience:

# Launch the TUI
joplin

# Navigation within TUI:
# - Tab: switch between sidebar, note list, editor
# - Arrow keys: navigate lists
# - Enter: open a note
# - q: quit (from sidebar)

Scriptable CLI workflows:

# Quick-capture a note from the terminal
joplin mknote "$(date): Quick thought"

# List all notes in a notebook
joplin use "Work"
joplin ls

# Search and display
joplin search "meeting"

# Dump note content to stdout
joplin cat "Note Title"

# Sync and exit
joplin sync

5.27 Configuring Keyboard Shortcuts

View and customize keybindings:

Desktop:

1. Tools → Options → Keyboard Shortcuts.
2. Click a command, press the desired key combination, click Save.

CLI:

# View current keymap
joplin keymap

Custom keymaps override default bindings. Changes take effect immediately without restart.

5.28 Email-to-Note (Joplin Cloud)

Joplin Cloud subscribers can forward emails to a unique email address that creates notes automatically:

1. Go to the Joplin Cloud web dashboard.
2. Find your unique email-to-note address.
3. Forward any email to that address.
4. The email appears as a new note on next sync.

5.29 Geolocation Workflows

Travel journaling:

1. Enable geolocation on mobile.
2. Create notes at each location — GPS coordinates are saved automatically.
3. Search notes by location:

latitude:48 longitude:2

This finds notes created near Paris (48N, 2E).

View on map:

Click the geolocation coordinates in note properties to open the location in Google Maps, OpenStreetMap, or your configured maps application.

5.30 Restoring Deleted Notes

Deleted notes go to the Trash notebook:

1. Open the Trash notebook in the sidebar.
2. Find the deleted note.
3. Right-click → Restore.

The note returns to its original notebook. If the original notebook was also deleted, the note restores to the root level.

CLI restore:

joplin restore "Deleted Note Title"

Permanent deletion:

To permanently delete notes from Trash, right-click → Delete permanently. This action is irreversible.

Caution

Emptying the Trash permanently deletes all notes in it. There is no undo for permanent deletion, and the notes cannot be recovered from sync targets after the next sync completes.

5.31 Table of Contents

Insert a table of contents into any note by placing the [[toc]] tag. Joplin automatically generates a linked table of contents from all headings in the note.

[[toc]]

# Section 1
Content here...

## Section 1.1
More content...

# Section 2
Even more content...

The table of contents updates automatically as you add or modify headings.

5.32 Note Linking and Wiki-Style Navigation

Build a personal wiki by linking notes together:

1. Create a hub note that serves as your index or dashboard.
2. Link to topic notes using the Markdown link syntax:

# Knowledge Base

## Development
- [Python Tips](:/{python_tips_id})
- [Docker Cheatsheet](:/{docker_cheat_id})
- [Git Workflows](:/{git_workflows_id})

## Projects
- [Project Alpha Status](:/{alpha_id})
- [Project Beta Roadmap](:/{beta_id})

3. Back-link from topic notes to the hub for easy navigation.
4. Use a Backlinks plugin for automatic bi-directional link discovery.

5.33 Daily Notes and Journaling

Set up a daily notes workflow:

1. Create a "Journal" notebook.
2. Use a template with date variables:

# {{date}} — Daily Log

## Tasks
- [ ] 

## Notes


## Gratitude

3. Each morning: File → New note from template → Daily Log.
4. Sort the Journal notebook by user_created_time to see entries chronologically.

5.34 Using Joplin for Meeting Notes

Meeting note template:

# Meeting: {{date}}

**Attendees:** 
**Agenda:**

## Discussion Points
1. 

## Action Items
- [ ] @person — task — due date

## Decisions Made
- 

## Follow-up
- Next meeting: 

After the meeting, tag the note with the project name and attendee names for easy retrieval.

5.35 Code Snippet Management

Use Joplin as a code snippet library:

1. Create a "Snippets" notebook.
2. Create notes for each language or topic.
3. Use fenced code blocks with language tags for syntax highlighting:

# Python — File Operations

## Read a file
```python
with open('file.txt', 'r') as f:
    content = f.read()
```

## Write JSON
```python
import json
with open('data.json', 'w') as f:
    json.dump(data, f, indent=2)
```

4. Tag with the programming language for quick filtering: tag:python, tag:javascript.
5. Search with notebook:Snippets tag:python to find Python snippets.

5.36 Clipping Research from the Web

Research workflow with Web Clipper:

1. Clip articles with Simplified page mode (strips ads and navigation).
2. Use a consistent tag scheme: research, topic-name, source-type.
3. Add your own annotations at the top of the clipped note.
4. The source URL is preserved automatically in note properties.
5. Search clipped content later with sourceurl:example.com or by tag.

5.37 Collaborative Workflows (Joplin Cloud/Server)

Team knowledge base:

1. Create a shared notebook (Joplin Cloud or Server required).
2. Invite team members with Can edit permission.
3. Everyone syncs the shared notebook alongside their private notebooks.
4. Use tags consistently for cross-team discoverability.
5. Publish important notes as public links for external stakeholders.

Limitations:

• Real-time collaboration (Google Docs-style) is not supported — changes sync on intervals.
• Conflicts can arise from simultaneous edits (see Section 5.25 for resolution).

5.38 Exporting for Publishing

Export to blog or website:

1. Write your post in Joplin with standard Markdown.
2. Export as Markdown (File → Export → Markdown).
3. Copy the .md file to your static site generator (Hugo, Jekyll, Gatsby, etc.).
4. Images export to _resources/ — update paths as needed.

Export to HTML for email:

1. Export as HTML.
2. Open the HTML file.
3. Copy the rendered content into your email client.

5.39 Automating with Cron Jobs

Automated daily backup:

# crontab entry: backup every night at 2 AM
0 2 * * * /usr/local/bin/joplin export /backup/joplin-$(date +\%Y\%m\%d).jex --format jex

Automated sync:

# Sync every 30 minutes
*/30 * * * * /usr/local/bin/joplin sync >> /var/log/joplin-sync.log 2>&1

Warning

Automated CLI sync must not run while the TUI or desktop app is active — only one process should access the Joplin database at a time. Schedule cron jobs for times when the interactive app is closed.

5.40 Portable Installation on USB

1. Download the portable release for your OS.
2. Extract to a USB drive.
3. Set the PORTABLE_EXECUTABLE_FILE environment variable to the Joplin executable path.
4. Launch Joplin — all data stores next to the executable on the USB drive.
5. Configure filesystem sync (Target 2) pointing to a directory on the same USB drive for a fully self-contained setup.

6. Troubleshooting

6.1 Sync Not Working

Symptoms: Notes do not appear on other devices; sync button shows errors.

Solutions:

1. Check connectivity: Ensure the device has internet access and can reach the sync target.
2. Verify credentials: Re-enter username and password in sync settings.
3. Check sync target URL: Ensure the URL is correct and includes the full path (e.g., Nextcloud needs /remote.php/webdav/Joplin).
4. Test configuration: Use the "Check synchronisation configuration" button in sync settings.
5. Reduce concurrent connections: Lower sync.maxConcurrentConnections from 5 to 1 and try again.
6. Check logs: Help → Toggle development tools → Console (desktop) or joplin status (CLI).
7. Re-sync from scratch: Delete the local sync state (not your notes) and force a full re-sync.

6.2 Encryption Errors

"Cannot decrypt item":

• You need the master password. Go to Tools → Options → Encryption and enter it.
• If you changed your master password, all devices need the new password.
• Old encrypted notes remain encrypted with the old key — supply both passwords if prompted.

"Master key not loaded":

• The master key file may be corrupted. Re-enter the password.
• If the master key was created on another device, sync first to receive it.

6.3 Missing Notes After Sync

Notes exist on one device but not another:

1. Ensure both devices sync to the same target.
2. Complete a full sync on the source device first.
3. Wait for the sync to finish on the destination device (large libraries take time).
4. Check the Conflicts notebook for duplicates.

Notes disappeared entirely:

1. Check the Trash notebook.
2. Check the Conflicts notebook.
3. Look at note history for recovery.
4. If using filesystem sync, check the sync directory directly.

6.4 App Won't Start

Desktop:

1. Reset the window state: delete window-state.json from the data directory.
2. Delete the cache folder (Cache/ in the data directory).
3. Rename the database file to force a re-sync (keep a backup).
4. On Linux, ensure FUSE is installed for AppImage.

Data directory locations:

• Windows: %APPDATA%\Joplin
• macOS: ~/.config/joplin-desktop
• Linux: ~/.config/joplin-desktop

6.5 Performance Issues

Slow with many notes:

• Disable showNoteCounts if you have thousands of notebooks.
• Set sync.resourceDownloadMode to manual to avoid downloading all attachments.
• Disable OCR if not needed — it processes every image in the background.
• Close unused plugins — each adds overhead.

Slow sync:

• Reduce sync.maxConcurrentConnections if the server throttles connections.
• Switch to a faster sync target (S3 or Joplin Server handle large libraries best).
• Use Joplin Cloud or Joplin Server rather than Dropbox/OneDrive for note-heavy accounts.

6.6 Web Clipper Not Connecting

1. Ensure Joplin desktop is running.
2. Enable the Web Clipper service: Tools → Options → Web Clipper → Enable Web Clipper Service.
3. Check that port 41184 is not blocked by a firewall or antivirus.
4. Restart Joplin desktop and the browser.
5. Reinstall the browser extension.

6.7 Mobile App Issues

Scrolling/rendering issues (known issue #15141):

Some users experience rendering glitches on mobile. Current workarounds:

• Restart the mobile app.
• Toggle between editor and viewer modes.
• Clear the app cache (Android: Settings → Apps → Joplin → Storage → Clear Cache).

Sync issues on mobile:

• Background sync may be killed by the OS battery optimizer. Add Joplin to the battery optimization exclusion list.
• On iOS, background refresh must be enabled in Settings.

6.8 Search Crashes (Known Issue #13322)

If search crashes with an older profile:

1. Back up your data (JEX export).
2. Delete the search index: remove search.sqlite from the data directory.
3. Restart Joplin — the index rebuilds automatically.
4. If the crash persists, try upgrading to the latest version.

6.9 OCR Not Working

OCR stops after processing a few resources (known issue #14805):

• Restart Joplin to resume processing.
• Check that ocr.enabled is still on after restart.
• Verify the ocr.languageDataPath is accessible.
• For handwritten text recognition, ensure you have a Joplin Server or Cloud connection — the ocr.handwrittenTextDriverEnabled setting requires server-side processing.

6.10 Image Context Menu Missing "Cut" (Known Issue #13895)

The right-click context menu on images does not include a "Cut" option. Workaround:

1. Use "Copy" instead.
2. Delete the original image.
3. Paste at the new location.

6.11 OneNote Import Hangs (Known Issue #15132)

The OneNote importer may hang during the postprocessing stage:

1. Allow extra time — processing can take much longer than the initial import.
2. If it genuinely hangs (no CPU/disk activity for 10+ minutes), force-close Joplin and try importing a smaller export.
3. Convert the OneNote notebook to PDF first, then clip or attach the PDF as an alternative.

6.12 Plugin Compatibility Issues

Plugin causes crashes or errors:

1. Start Joplin in safe mode: Help → Toggle safe mode (or rename the plugins directory temporarily).
2. Disable plugins one at a time to identify the offending plugin.
3. Update the plugin or report the issue to the plugin developer.
4. Rollback: delete the plugin from the plugins/ directory in the data folder.

6.13 Database Errors

"Database is locked" or "SQLITE_BUSY":

• Only one instance of Joplin should access the database at a time.
• Close any other Joplin processes.
• On shared filesystems (NFS, network drives), ensure only one device accesses the database file directly.

"Database disk image is malformed":

1. Close Joplin.
2. Back up the database file.
3. Run SQLite integrity check:

sqlite3 database.sqlite "PRAGMA integrity_check;"

4. If corrupted, export via JEX (if possible) and reimport into a fresh profile.
5. Alternatively, delete the database and re-sync from the sync target.

6.14 Markdown Rendering Issues

Notes look different between desktop and mobile:

• The desktop and mobile renderers have minor differences. Stick to standard Markdown for maximum compatibility.
• Custom CSS (userstyle.css) only applies to the desktop.

Math (KaTeX) not rendering:

• Ensure the math plugin is enabled (it is built-in).
• Use $...$ for inline and $$...$$ for block math.
• Complex LaTeX commands may not be supported — KaTeX covers a subset of LaTeX.

6.15 External Editor Not Working

The external editor does not launch:

1. Check the EDITOR environment variable is set correctly.
2. The editor must support being launched from the command line.
3. For GUI editors, use the --wait flag: export EDITOR="code --wait" or export EDITOR="subl --wait".
4. On Windows, ensure the editor is in your PATH.

6.16 Proxy Issues

Behind a corporate proxy:

1. Set proxy environment variables before launching:

export https_proxy=http://proxy.corp.com:8080
export http_proxy=http://proxy.corp.com:8080
joplin

2. For authenticated proxies: export https_proxy=http://user:[email removed]:8080
3. Some sync targets (OneDrive, Dropbox) may not work through proxies that intercept HTTPS. Use Joplin Server or WebDAV instead.

6.17 Attachment Download Failures

"Resource not downloaded" errors:

1. Check your internet connection.
2. Verify the sync target is accessible.
3. Switch sync.resourceDownloadMode to always temporarily.
4. Run a full sync.
5. Check that the resource exists on the sync target (especially if switching between targets).

6.18 Desktop Notifications Not Working

Alarms/reminders do not appear:

• Ensure desktop notifications are enabled in your OS settings.
• Joplin must be running (not just minimized to tray).
• On Linux, ensure libnotify is installed: sudo apt install libnotify-bin.
• Check that the alarm time is set correctly (timezone matters).

6.19 High Memory Usage

Joplin consuming excessive RAM:

1. Disable unused plugins — each plugin runs in its own process.
2. Close the note viewer pane (use Editor-only layout) for very large notes.
3. Reduce the number of open windows (multi-window mode uses more memory).
4. Clear the cache: delete the Cache/ directory.

6.20 Sync Conflict Resolution

Many notes in the "Conflicts" notebook:

1. Open each conflict note.
2. Compare with the original (the non-conflict version in its original notebook).
3. Merge changes manually.
4. Delete the conflict note.
5. To prevent future conflicts: sync before and after editing, and avoid editing the same note on multiple devices simultaneously.

6.21 Cannot Find Notes

Notes seem to have vanished:

1. Use global search (Ctrl+G / F6) — it searches across all notebooks.
2. Check if a filter is active (tag filter, notebook filter).
3. Look in the Trash notebook.
4. Look in the Conflicts notebook.
5. Check the "All Notes" view (click the notebook header in the sidebar).
6. If using E2EE, ensure all master keys are loaded — encrypted notes may not appear in search.

6.22 Portable Mode Issues

Data stored in wrong location:

• On Windows, portable mode activates when PORTABLE_EXECUTABLE_FILE is set.
• On Linux AppImage, APPIMAGE is set automatically.
• Data is stored next to the executable in portable mode.
• If switching between portable and installed modes, your data will be in different locations.

6.23 SSL Certificate Errors

When syncing with self-hosted servers:

1. Ensure the server has a valid SSL certificate.
2. For self-signed certificates, Joplin may not connect. Use a proper certificate (e.g., Let's Encrypt).
3. On some platforms, adding the CA certificate to the system trust store resolves the issue.

6.24 Command-Line Sync Automation

Automate sync via cron:

# Sync every 30 minutes
*/30 * * * * /usr/local/bin/joplin sync >> /var/log/joplin-sync.log 2>&1

Caution

The CLI sync command must not run while the TUI or desktop app is also running — only one process should access the database at a time. Schedule automated sync for periods when no interactive instance is active.

6.25 Data Recovery from Sync Target

If all local data is lost:

1. Install a fresh copy of Joplin.
2. Configure the same sync target.
3. Sync — all notes download from the sync target.
4. If E2EE was enabled, enter the master password when prompted.
5. Attachments download according to sync.resourceDownloadMode.

6.26 Slow Initial Sync

First sync taking hours:

• This is normal for large libraries with many attachments.
• Set sync.resourceDownloadMode to manual during initial sync to skip attachment downloads. Switch back to always or auto afterward.
• Increase sync.maxConcurrentConnections (up to 20) if the sync target can handle it.
• Use a wired connection instead of Wi-Fi for the initial sync.

6.27 "Too Many Requests" Errors

Cloud sync targets (OneDrive, Dropbox, Joplin Cloud) may rate-limit frequent requests:

1. Reduce sync.maxConcurrentConnections to 1 or 2.
2. Wait a few minutes and try again.
3. For persistent issues, increase the sync interval to reduce request frequency.

7. FAQ

General

Q1: Is Joplin free?

Yes. Joplin is free and open source (AGPL-3.0 for the apps / MIT for libraries). The desktop, mobile, and CLI apps are free. Joplin Cloud is a paid service for sync and sharing, but you can use free alternatives (Nextcloud, Dropbox, OneDrive, filesystem, etc.).

Q2: What format are notes stored in?

Markdown. Notes are plain text Markdown files with metadata. Attachments are stored as separate resource files referenced by ID.

Q3: Can I access my notes without Joplin?

Yes. Export to Markdown (File → Export all → Markdown) to get plain .md files. You can also read the SQLite database directly or access the sync target files (though they are in Joplin's internal format).

Q4: Is Joplin available in my language?

Joplin supports dozens of languages via community translations. Set the locale in Tools → Options → General → Language. If your language is missing or incomplete, you can contribute translations on GitHub.

Q5: Can I use Joplin offline?

Yes. Joplin is an offline-first application. All notes are stored locally. Sync is optional and only needed for multi-device access.

Q6: What platforms does Joplin support?

Windows, macOS, Linux (desktop via Electron), Android, iOS (mobile via React Native), and any platform with Node.js (CLI). The Web Clipper extension supports Chrome, Firefox, and Chromium-based browsers.

Q7: How do I check my Joplin version?

Desktop: Help → About Joplin. CLI: joplin version. The version number is also shown in the title bar.

Notes & Editing

Q8: Can I use HTML in notes?

Yes. Joplin supports mixed Markdown and HTML. You can also import HTML notes directly. The editor.enableHtmlToMarkdownBanner setting offers to convert HTML notes to Markdown.

Q9: What Markdown flavour does Joplin use?

GitHub-flavoured Markdown (GFM) with extensions for KaTeX math, checkboxes, highlighted text, and Joplin-specific link syntax.

Q10: Can I embed videos in notes?

Attach video files like any other resource. They render as a download link. For embedded playback, use an HTML <video> tag with the resource ID.

Q11: Is there a word count?

Yes. Note statistics (word count, character count) are shown in the note info panel. Some plugins add a persistent word count display.

Q12: Can I password-protect individual notes?

Not individually. E2EE encrypts all notes globally. For per-note protection, use a plugin or store sensitive content in an encrypted notebook shared only with yourself.

Q13: How large can a note be?

There is no hard limit in Joplin's code, but very large notes (100,000+ words) may slow the editor. Sync targets may have their own size limits.

Q14: Can I insert a table of contents?

Yes. Use the [[toc]] syntax in a note to generate an automatic table of contents from headings.

Q15: Does Joplin support syntax highlighting in code blocks?

Yes. Use fenced code blocks with a language identifier (e.g., ```python, ```javascript, ```bash). Joplin supports highlighting for most common programming languages.

Q16: Can I use Vim or Emacs keybindings in the editor?

Not natively, but plugins can add alternative keybinding modes to the CodeMirror editor.

Synchronisation

Q17: How often does Joplin sync?

By default, every 5-10 minutes (configurable). You can also manually trigger sync at any time.

Q18: Can I use multiple sync targets simultaneously?

No. Joplin syncs to one target at a time. To maintain backups on a second target, switch targets, sync, then switch back — but this is not recommended for routine use.

Q19: Does sync use much bandwidth?

Initial sync transfers all notes and attachments. Subsequent syncs only transfer changes (delta sync). Notes are small; attachments are the main bandwidth driver.

Q20: Can I sync specific notebooks only?

No. Sync is all-or-nothing. All notebooks sync to the target. Use sync.resourceDownloadMode: manual to skip downloading large attachments on secondary devices.

Q21: What happens if the sync target is full?

Sync fails with a storage error. Free space on the target or upgrade your storage plan. Local notes are not affected.

Q22: Can I move from one sync target to another?

Yes. The recommended process:

1. Sync fully with the old target.
2. Switch to the new target in settings.
3. Sync fully with the new target.
4. Verify notes appear correctly.
5. Optionally, delete data from the old target.

Q23: Which sync target is fastest?

Joplin Server and Amazon S3 generally offer the best performance for large libraries. OneDrive and Dropbox are convenient but may be slower due to API rate limits.

Encryption

Q24: What encryption does Joplin use?

AES-256-CBC for note content. RSA for key exchange (public-private key pairs for sharing). Master keys are derived from your password.

Q25: Can I share encrypted notes?

Yes, with Joplin Cloud or Joplin Server. The PPK (public-private key pair) system allows encrypted sharing between users. The recipient's public key encrypts the shared content.

Q26: Does encryption affect search?

No. Joplin searches the decrypted content locally. Search only works on devices where the master password has been entered.

Q27: Can I disable encryption after enabling it?

Yes. Go to Tools → Options → Encryption and click Disable encryption. All notes are decrypted on the next sync. Other devices receive the decrypted versions after syncing.

Plugins

Q28: Are plugins safe?

Plugins run with access to your notes and local API. Install only from the official plugin directory or trusted sources. Review plugin permissions before installing.

Q29: Can I write my own plugin?

Yes. Plugins are JavaScript/TypeScript packages. Create a manifest.json, implement the Joplin plugin API, and build with the Joplin plugin generator:

npx yo generator-joplin

Q30: Do plugins sync across devices?

No. Plugins must be installed separately on each desktop device. Plugins are not available on mobile.

Q31: How many plugins can I install?

There is no enforced limit, but each plugin adds memory and startup time overhead. Install only what you actively use.

Mobile

Q32: Does mobile have all desktop features?

Most features are available. Missing or limited: plugin support, custom CSS, external editor integration, advanced keyboard shortcuts.

Q33: Can I use mobile offline?

Yes. All synced notes are available offline. Attachments depend on the sync.resourceDownloadMode setting.

Q34: Does the mobile app support biometric unlock?

Yes. On Android and iOS, you can enable fingerprint/face unlock in the app settings.

Q35: Can I draw or handwrite on mobile?

Not natively. Use a drawing app, save the image, and attach it to a Joplin note.

CLI

Q36: Can I use the CLI without the TUI?

Yes. Run individual commands non-interactively:

joplin ls          # List notes
joplin cat "Title" # Print a note
joplin sync        # Run a single sync
joplin search "q"  # Search

Q37: Can I pipe content into Joplin from the terminal?

Yes. Use the mknote command with shell substitution or attach files via the attach command:

# Create a note from command output
joplin mknote "$(hostname) status: $(uptime)"

# Attach a file
joplin attach "My Note" /path/to/file.pdf

Q38: Does the CLI support all sync targets?

Yes. The CLI supports every sync target the desktop does, including Joplin Cloud, Joplin Server, Nextcloud, WebDAV, OneDrive, Dropbox, S3, and filesystem.

Import & Export

Q39: Can I import from other note apps?

Directly supported: Evernote (ENEX), OneNote (ONEPKG), Markdown files and directories. Many other apps can export to one of these formats. Community-maintained importers exist for additional sources.

Q40: Can I export to Word or Google Docs?

Not directly. Export to Markdown or HTML, then import into Word/Docs. The HTML export preserves formatting best.

Q41: Does JEX export include everything?

Yes. JEX includes notes, notebooks, tags, attachments, metadata, and encryption data. It is a complete backup.

Web Clipper

Q42: Does the Web Clipper work with Firefox/Chrome/Edge?

The extension is available for Chrome (also works in Edge, Brave, and Chromium-based browsers) and Firefox.

Q43: Can I clip to a specific notebook?

Yes. The Web Clipper popup lets you select the destination notebook and add tags before clipping.

Q44: Does the Web Clipper work without Joplin desktop running?

No. The Web Clipper communicates with the Joplin desktop app via its local REST API. The desktop app must be running.

Data & Privacy

Q45: Where is my data stored?

Locally on each device. Sync copies exist on the sync target only. Joplin (the project) has no access to your data unless you use Joplin Cloud.

Q46: Can I use Joplin with zero cloud dependency?

Yes. Use filesystem sync to a local drive or do not configure sync at all. All data stays on your device.

Q47: Does Joplin collect telemetry?

Minimal. Joplin may check for updates. No note content is ever transmitted to Joplin's servers (unless using Joplin Cloud for sync).

Advanced

Q48: Can I use Joplin as a wiki?

Yes. Use internal links ([Title](:/{note_id})) to create a wiki-like structure. Note backlinks plugins add bi-directional linking. Tags and notebooks provide additional organization.

Q49: Can I automate Joplin with scripts?

Yes. The REST API (port 41184) allows full CRUD operations on notes, notebooks, tags, and resources. The CLI supports non-interactive commands for shell scripting. Together, they enable cron jobs, integration with other tools, and custom workflows.

Q50: How do I report a bug?

File an issue on GitHub: github.com/laurent22/joplin/issues. Include:

• Joplin version (Help → About Joplin or joplin version)
• Operating system and version
• Sync target type
• Steps to reproduce
• Log output (Help → Toggle development tools → Console)

Q51: What is the difference between user_updated_time and updated_time?

user_updated_time is when you last edited the note content. updated_time includes any metadata change (tag added, note moved, sync-related updates). Sorting by user_updated_time gives a more intuitive "last edited" order.

Q52: Can I host my own Joplin Server?

Yes. Joplin Server is open source and available as a Docker image (joplin/server). It provides sync, sharing, publishing, and email-to-note features. See the setup instructions in Section 3.5.

Q53: Can I use multiple profiles?

Yes. Launch Joplin with a different profile directory:

# Desktop: set the profile path at startup
joplin --profile /path/to/alternate/profile

# CLI
joplin --profile /path/to/alternate/profile

Each profile has its own database, settings, and sync configuration.

Q54: What happens if I delete a notebook?

The notebook and all notes inside it are moved to the Trash. They can be restored until you permanently empty the Trash.

Q55: Can I change the default data directory?

Yes. Use the --profile flag to point Joplin to any directory. On desktop, you can also set this via command-line arguments in a shortcut.