Any suggestions on what web technology could be used to add support for sharing notes?

I don’t have a concrete proposal. I had an occasion in which a friend and I wanted to collaborate on a set of notes for a particular task. We tried using a Google Docs Sheet (spreadsheet) on my Google Drive, and that worked really well. No installation necessary, and the functionality we needed was pretty minimal. The Drive infrastructure took care of the mechanics of sharing.

Again, I don’t really have a working idea for how Joplin can use this technology, but wanted to toss it out in case it inspires someone else. Maybe for purposes of sharing a Joplin note, rather than trying to use Joplin’s native data store and functionality, a more basic export/import approach is possible using Google Drive’s native capabilities. And I’m not sayng to focus just on Google Drive; DropBox also has a sharing capability. So export a note, let participants collaborate on it on Google Drive, DropBox, whatever, and at the end, if desired import that note.

1 Like

@leobard, adding support for multiple profiles would definitely handle certain use cases, for example you could have personal notes on one profile and work notes, shared with colleagues, on another profile. Since it’s indeed easier to support this than developing a new server, it’s relatively high priority to add this.

The main obstacle at the moment is that it’s difficult to restart a mobile app, and for iOS, it looks like it’s going to be forbidden soon. Without being able to restart the app, we’ll have to develop complex logic to allow switching the profile dynamically which would a huge task as Joplin wasn’t designed for that.

Also a drawback of this approach is that you have to install Joplin, setup the sync target, etc., which is too much for just sharing a note. Let’s say you want to organise a day trip somewhere for several people, you create a note in Joplin with the schedule, maps, etc. then you share this note with everybody. For this scenario, we need to be able to share a single link without a requirement to install Joplin.

Alas, with regard to collaborative editing, I think it is possible to reuse existing tools, such as Live Share. Collaborative editing is a very complicated matter. I don’t recommend Joplin to touch this.
As for sharing, I think that as long as there is a static site generator, and then deploy some content that needs to be shared on the public network, send the link out, and it’s over.

For encryption issues, you can refer to existing static blogs and use the salted hash string as the password. Only the author knows the salt.

ref link:

1 Like

Hi @laurent

Sharing a note: the user story you describe - “organize a day trip, share it”. It does not need the recipient to always have the latest version. The sender can send the update. The straightforward approach would be to pack the note into a HTML or PDF and send it over. The HTML embedding would be quickest for you, as it is JS-friendly. If you use canvas and toDataURL() you can embed image as base64. That leaves you with one cross-plattform compatible HTML and you are done.

I would start with that and declare the following design decision to go forward: “joplin is currently a single-user note-taking tool supporting multiple store backends and no server. Sharing notes is a good case, I want to support that, so we do (HTML|PDF) export. That is a minimal incremental improvement and satisfies the immediate case. For collaborative editing, we also have this on our agenda, but it needs account switching.”.

The approach I would go for is multi-sync-target config and switching in the gui. Having multiple stores in parallel is something people know from other note-taking tools or from email clients. I would start by letting people “switch”. Have two folders on disk that carry the storage data. Once this works and is established (which will take months, if not years), an integrated “all notes from all stores” view is something to think about. But only then. One step after another.

Users needing collaborative editing right now should use a popular plattform that supports this today such as NextCloud or Google Docs.

If I had 2 Joplin app (the blue one and a green one for instance) it will fit my needs. Ok maybe it’s not very efficient but it will allow me to share some notes with my family and keep others for me.

DevOps, eh? :wink:

My thoughts are like this:

  • There’s a desktop client
  • There’s an android/iOS client
  • There’s a CLI client

They all operate via SYNC functionality.

So in order for collaboration to happen, or to have something like Evernote, all that’s missing is a web server which operates on the same SYNC functionality that will act as a web client.

For collaboration on the web client you can have:

  • Owner user/password
  • Invited user with password
  • password-less access to notes (public)
  • anyone with password can access

like the CLI, nodejs can be leveraged. Some framework like hapijs, fastifyjs or whatever.

If set up right, the web server could be deployed on for example (would be free for this use-case) or if you have your own server.

Does anyone here know

they even list some competing products

but also check the so called dead ones, e.g. TogetherJS is still alive

After reading all the comments I can see there are many options with their pros and cons and we just need to find the option which is suitable for most of the users, easy to develop and don’t restrict the further development of Joplin.

  1. We have the option to use NextCloud, Google Drive, or any such service as a sync target:
    • Pros:
      This is a great option for the user’s point of view as users won’t have to do anything and they will get the option to share notes with others.
  • Cons:
    Users have to use different sync and set up everything just to share notes.
    Devs have to setup code for every sync targets and make sure they’re also synced with each other.
    Some services have good docs for their services like google drive and all but many sync targets have bad docs.
    No. of shared folders is limited by no. of sync targets.
  1. Creating a nextcloud server:
    Pro: Very easy for the user to use it.
    Pro: Less work for the devs.
    Con: Bad ( at least for me ) docs.
    Con: Will depend on NextCloud for many things and features in Joplin, so very restrictive in my opinion.
    Con: Will have to learn differently techs and make a separate server that can rarely be used later as many tech and frameworks are NextCloud specific.

  2. Creating a Joplin Server:
    Cons: Will be difficult for the user to setup
    Cons: Too much work.
    Cons: Need payment method if we’re going to provide the user an option to use the Joplin server instead of setting up their server.

According to me best option here is to go with the Joplin specific server. I have a few reasons for that:

  1. All cons are solvable and we don’t have to depend on third party services.
  2. Will allow Joplin to add much new functionality and ease to user after having a custom server.
  3. We can develop a “real note sharing feature” with both link sharing and live editing options.
  4. Will be very easy for the user to use ( if they are using Joplin server, if they want to install it on their own we need to make the server with a good GUI so that a non-tech person can also install it in an easy way, also if someone can install NextCloud server, I don’t think they’ll have issues installing Joplin server ).
  5. As we can use the latest protocols and tech, we’ll see a performance improvement.
    and many more.

Flow of the feature:

Users just have to click on a note and they’ll get a sharable link and a password for the note ( password is optional ), they can share that with anyone and they can see and edit that note and that’s it. Easiest and simplest it can get and now there are no issues of folders, sync targets handling different scenarios. Those who want to share a single note or multiple notes or a folder will be the same for everyone.


First of all, as we’re going to use our own server, we don’t have to change much in the existing codebase and in a very vague way, we just have to take the content from a note and send it to the backend and show it on a link and for the changes, we just have to make an API call and then update the content of the note in the app.
We can create a Node.js (or any other tech) backend which will receive the data and generate the note and will send the link to that note.


My two cents: Existing platforms like dropbox, nexcloud, … already offer lots of sharing-related features that users probably expect nowadays. Examples are

  • sharing data publicly (easiest)
  • sharing with password-protection
  • sharing with selected users (who have credentials)
  • time-limited sharing (this share expires at date XYZ)

Using a custom server means that these cannot be leveraged (so either are not available, or need to be rebuild which I guess is vastly out of scope).

As for sharing read-only notes for non-joplin users, don't reinvent the wheel.

Right now, I copy everything over to a hugo site, relinking any attachments. The attachments are quite time-needy, as they need to be renamed (in markdown or the file). For basic text, this is fine, but for special syntax, it might not work.

The preview view is an iframe anyways, I would guess getting / exporting as html not that hard, as you don't have to build much new.

Of course, exporting markdown with attachments, then re-implementing all rendering in a SSG is possible, but it's not very practical.

html files can be hosted easily. Now, from the user side, making joplin upload a file unencrypted to a remote (the ones implemented), in a specified directory (joplinroot/hosted-notes for example), and then generating a link based on configuration is possible.
The webserver serves from the directory (or the directory is synced to it) to domain.tld/j/. When the user decides to share, generate a short either mnemonic or 4-6 alphanumeric string, allowing the user to rename it. Say user named it to my-note, the attachments will be in domain.tld/j/my-note, and the rendered result in domain.tld/j/my-note/index.html. From preconfigured settings, joplin knows it needs to pre-append https://domain.tld/j/. This could also be present in the UI on renaming the path.

Now who likes setting up stuff with webservers? Joplin-hosted notes. It's a revenue source for the developers, and provides easy setup to users. When selected, and stored, credentials are synced with clients. 3$/yr for example (warn: maybe load cap of like n visitors per note per month.. or just auto-scale). The public directory is just pushed to a different remote.

Pardon for bad unedited writing, have to go atm.

Tldr take output of rendered html in joplin, along with downloadable attachments (non-images), throw them in a directory (optionally hosted by joplin), where it reaches the web server. Web URL path is pre-appended, and presented to the user. User may change path/sub-path or choose to remove (simple move, remove commands), select, if the note should be auto-updated, and select a (latest) version to be hosted.

I would imagine there really wouldn't be many sync conflicts, for the public directory, but the area needs to be thought of anyway.

Ping me to remind me. I can draft up code design docs and UI examples.

how about having a public notebook folder? the public notebook folder is a special share folder (like trash folder) that contains unencrypted files like txt or md. We can then use any 3rd party cloud provider that support collaboration like onecloud or dropbox to share and collaborate on notes. After the person is done with editing, you can move the notes into other notebook to make it private.

Many of the issues regarding syncing, resolution, and agnostic connections may be addressed by this collaborative framework; it's gained some purchase recently, and appears robust enough to handle cited use cases.

Looks like other note taking apps may have also leveraged it already, so may offer some road tested scenarios against which to plan and test.

The issue with this is that there would have to be bespoke code for each provider (OneDrive, Dropbox, etc.) and this is the kind of code that often breaks as APIs change and so on, so it wouldn't be maintainable. If there was standard way to share (like WebDAV for sync) that can be developed once and then keep working, why not, but there's nothing like it unfortunately.

1 Like

Having a public folder is about the same as exporting a note, then going to the trouble of hosting it yourself..

Peer-to-peer, without an almost always online node is not user-friendly: What if you edit on your side only while the other side is offline.
As for hosting, publicly sharing, having it accessible without extra software is sane.

Yes I'm not sure peer to peer is the right model for sharing either. It means the client has to be started and running as a server for someone else to view the shared note.

If there's an intermediate server, you can simply publish the note, then close your laptop and the person you shared with can view the note whenever they want to (without having to wait for you to go back online).

Assumed the shared note also contains the unique note id then the receiver can import it and subsequently edit it. Once he finished his changes he could share his modified version back. If the sender didn't change his copy since he shared it, the new version just replaces his one. If both parties concurrently changed the shared note, a conflict could be indicated like it is done with conflicts during synchronization.

Something like this?

BTW, with sharing I mean any method that would allow a note to be transferred. E-Mail, Messenger, direct WiFi connection, Bluetooth, etc. Just anything the a smart phone's or desktop's OS provides.

If it was as easy to share Joplin notes as it is with other documents/files (e.g. PDFs, Images, etc) then one would have the asynchronous workflow you outlined above for free. The intermediate server you "published" to would then be an email sever, a messenger server, etc.

I believe the easiest way to share notes would be to enable multiple profiles:

This topic is somewhat outdated as Joplin Server/Cloud has been released since this topic was relevant which features note sharing.

1 Like