kimonote's notes tagged 'kimonote'

(notes) / (tags) / (streams)

View: compact / full
Time: backward / forward
Source: internal / external / all
Public RSS / JSON

(show contents)

Kimonote API

@kimonote (link) 4 years, 6 months ago | kimonote | announcements | api | 1 comment

Kimonote now has a basic REST API with a couple of endpoints that allow you to get a JSON version of any stream as well as programmatically create, update, read and delete notes.

More information in the User Guide!

Kimonote now supports bookmarklets!

@kimonote 4 years, 6 months ago | kimonote | announcements | bookmarklets |

Kimonote now supports bookmarklets: tiny snippets of code that allow you to quickly create a new note/bookmark without leaving the website you're on. For example, this bookmarklet will show the Kimonote note creation view, prepopulated with the currently selected text and a link to the page you're currently viewing.

javascript:(function(){open(''+encodeURIComponent(location.href)+'&title='+encodeURIComponent(document.title)+'&text='+encodeURIComponent(window.getSelection().toString()).replace(/#/g, '%23'),'targetname','height=500,width=300');})()

Alternatively, copy this link to install the bookmarklet.

More information is available in the User Guide.

Kimonote: Comments and changes to RSS importers

@kimonote 4 years, 6 months ago | kimonote | announcements | comments |

Kimonote now supports optional comments on public notes. Comments can be edited by their creator and deleted by their creator or the note owner.

In addition, notes imported via RSS are now uneditable: this is to allow the imported note to update when the upstream RSS entry gets updated. Editing an imported note now reblogs it into your private notes, creating a copy that won't get updated.

The final minor change is that you can now attach a link to any note, public or private. Notes imported from RSS have their link set to whatever that RSS entry was pointing to.

As always, feedback is welcome at!

Kimonote: RSS importers

@kimonote 4 years, 6 months ago | kimonote | announcements | rss |

Kimonote now supports RSS importers: you can set it up to poll RSS feeds and add new entries from them into your personal notes.

In conjunction with the e-mail exporter function, this allows you to build newsletters that deliver information to you at frequencies that you decide instead of continuously checking your favourite websites for news.

RSS importer settings can be accessed at Manage -> Importers from the navigation bar in the top right corner. As always, feedback is welcome at!

Kimonote: announcing stream exporters + small changelog

@kimonote 4 years, 7 months ago | kimonote | announcements | streams | exporters |

Kimonote now supports stream subscriptions, or exporters. You can configure Kimonote to send you a weekly/daily/hourly/5-minutely digest of new notes in a given stream. There's a small guide on how to use them, available here.

In addition, there are some minor bugfixes/changes to Kimonote:

  • Default streams have been added (tags/users can be quickly added to them with just one click).
  • Unicode note/tag names are now supported (there was a small bug in the URL generation that led to them not being able to be routed to).
  • Some e-mail providers were rejecting Kimonote e-mails because of a lack of some DNS records. This should now be fixed.
  • Stream fetching queries have been optimized.
  • E-mail verification is now optional, but you do need a verified e-mail to post new notes or to send stream digests to it.
  • You can no longer set the note date. The note is timestamped with its creation date at first, then with its publication date when it's published for the first time. This is for a better experience with stream digests and to avoid subscribers accidentally missing new public notes.

As always, feedback is welcome at!

Kimonote User Guide

@kimonote 4 years, 7 months ago | kimonote | guide |


Kimonote is a text-first minimalist blogging platform and note organizer that focuses on ease of navigation and control over content that a user follows.

This is a rough outline of Kimonote features and how to use them. If you prefer a more interactive guide, why not try the Kimonote demo?

If there's anything left unclear after reading this guide or anything you wish to see added, please contact!

Creating and editing notes

Go to to create a new note. You can use Markdown to write notes. Images are supported, but only if they're hosted externally for now.

Tags are supported and encouraged. Kimonote can also suggest tags based on the contents of the note using natural language processing. To get a suggestion, simply edit the note after it's been written.

In the edit view, you can also set whether a note is public or not.

Finally, you can also attach a link to the note, allowing for bookmarking.


The note creation view supports link, title and text query parameters, setting its initial values. This allows for bookmarklets that let you quickly bookmark some text or a note in Kimonote. For example:

javascript:(function(){open(''+encodeURIComponent(location.href)+'&title='+encodeURIComponent(document.title)+'&text='+encodeURIComponent(window.getSelection().toString()).replace(/#/g, '%23'),'targetname','height=500,width=300');})()

This bookmarklet will show the Kimonote note creation view, prepopulated with the currently selected text and a link to the page you're currently viewing.

Alternatively, copy this link to install the bookmarklet.


Kimonote focuses on minimal page sizes and so uses almost no JavaScript. One exception is MathJax, which allows to typeset mathematical formulas using LaTeX. You'll need to escape some of Tex's control characters in order to be able to use them in Markdown.

For example:

\\[ \\frac{a\_1}{b\_1} \\]

becomes \[ \frac{a_1}{b_1} \]

To get MathJax to load in your note, tick "MathJax" in the edit view.

Tag-based navigation

User's notes that have the same tag are linked together in the note view, meaning that you will never need to set up links between posts from the same series again. For example, if you have three notes:

  • A is tagged a, b, c
  • B is tagged b
  • C is not tagged at all
  • D is tagged a, b

Then Kimonote will automatically generate links:

  • from A: to B (since they're both tagged b) and D (since they're both tagged a);
  • from B: to A and C (since it's the next post in the blog);
  • from C: to B and D (since they're the previous and the next post);
  • from D: to A (since both are tagged a), B (since both are tagged b) and C (since it's the previous post).


Streams are collections of notes from certain users with certain tags that can help you organize your content or follow just specific notes from a user. A stream view can be accessed at:,tag2,tag3,@user2,@user3:tag2,tag3

This means you'll see, in that view, all public posts from user1 tagged tag1, tag2, tag3; all posts from user2 and all posts from user3 tagged tag2 and tag3. If you are included in the stream (and are logged in), you'll see your private posts too.

You can change the current stream view by clicking on "(show contents)" on the sidebar or just appending ?edit=1 to the URL. This gives you a visual interface that lets you inspect what the stream contains or change its contents.

You can also search through all notes in a given stream, change the view between compact and full, as well as show notes ordering them by post time ascending or descending (useful for reading some long-form series).

Finally, there's an RSS feed available for every stream containing its public notes: click the link on the sidebar or append /rss/ to the URL.

Named streams

You can save a stream you're viewing: this allows you to, for example, see when it's been updated. Streams you have saved are available at the top in "(my streams)".

To save a stream, click on "Save as new / existing" in the contents menu on the sidebar. Here, you can either name a new stream or select a stream to overwrite or merge the current view with.

A saved stream's contents show by default. If you wish to edit them, you will be redirected to a temporary stream view and after you're done editing, you can overwrite the saved stream with the new contents.

Default streams

You can have one default stream. When you're viewing any other unnamed stream (such as all posts from a user with a given tag), you can add its contents to this stream directly: just click "Follow in..." in the sidebar. The default stream can be changed by opening a stream and clicking "(set as default)" in the sidebar.


Stream exporters push new notes in a given stream to a specified destination. Currenly, only e-mail is supported, but in the future, the ability to push contents to Facebook/Twitter or other social media platforms will be available. The e-mail exporter allows you to get a digest of all new items in a given stream.

To view all exporters for a stream, go to the stream view and click on "Manage subscriptions...", and to view all of your exporters, go to "(manage)" in the top right corner and then on "Exporters".

For an e-mail exporter, you can specify the target e-mail (which must be one of your verified e-mail addresses) as well as a schedule (every 5 minutes, hourly or daily at a given hour).

When you create your account and verify your e-mail, you get a default stream called "My subscriptions" created for you, containing all posts by @kimonote. It's linked to an exporter that notifies you when Kimonote publishes a new post. If you don't wish to be notified, you can either delete the exporter or delete the stream.


Kimonote can act as an RSS feed reader with its importer function: you can set it up to poll a given RSS feed and convert its contents into your own private notes with some tags. To filter whether you wish to see notes written by yourself or imported from a different source, you can choose between internal or external sources in the note overview.

Your current importers can be managed in the Manage screen on the right side of the navigation bar.

Together with the e-mail exporter function, you can create your own newsletters and receive digests from RSS feeds at any frequency. One way of doing it would be creating a stream that follows yourself and add an e-mail exporter to it, configuring it to only send notes imported externally. Alternatively, you can set up your importers to assign different tags to your notes and subscribe to them at various frequencies.


Kimonote has a basic REST API to list notes in a stream as well as create/read/update/delete notes.

Firstly, you can append json/ to any stream URL to get a JSON-formatted list of notes like this. Only the first 15 notes are returned. To get to the next page, append ?from=(id of the last note in the result), for example, like this. You'll only see your public notes if you're not authenticated.

Authentication happens by submitting a POST request with your username and password to In exchange, you will get an API token which you should submit with all of your requests as a header: Authorization: Token (your token).

Secondly, contains an API that allows you to programmatically create, update and delete your own notes. This API works only when you're authenticated. It's easier to showcase what the API can do with a bit of Python code, using the Requests library:

import requests

ROOT = ''
API_ROOT = ROOT + 'api/'
USERNAME = # your username here
PASSWORD = # your password here

# Obtain the token
token = + 'login/', json={'username': USERNAME, 'password': PASSWORD}).json()['token']
HEADER = {'Authorization': 'Token %s' % token}

# An OPTIONS request shows the format the API expects a note to be in, as well as the calls it supports
print(requests.options(API_ROOT + 'notes/', headers=HEADER).json())

# Let's create a new note by making a POST request to the API endpoint
new_note = {'title': "Test note",
            'is_public': True,
            'has_mathjax': False,
            'text': "Test note",
            'tags': ['test', 'note'],
            'link': ''}
new_note_id = + 'notes/', json=new_note, headers=HEADER).json()['id']

# Now let's update the note's title using a PATCH request
requests.patch(API_ROOT + 'notes/%d/' % new_note_id, json={'title': 'Test note: updated'}, headers=HEADER)
note = requests.get(API_ROOT + 'notes/%d/' % new_note_id, headers=HEADER).json()
assert note['title'] == 'Test note: updated'

# Now copy someone else's note
new_note_2 = requests.get(ROOT + '@kimonote/json/', headers=HEADER).json()[0]
new_note_2_id = + 'notes/', json=new_note_2, headers=HEADER).json()['id']
note = requests.get(API_ROOT + 'notes/%d/' % new_note_2_id, headers=HEADER).json()
assert note['text'] == new_note_2['text']

# Finally, delete the two notes we created.
requests.delete(API_ROOT + 'notes/%d/' % new_note_id, headers=HEADER)
requests.delete(API_ROOT + 'notes/%d/' % new_note_2_id, headers=HEADER)

Kimonote public beta

@kimonote 4 years, 7 months ago | kimonote | announcements | beta |

Kimonote is now open for a public beta test. Feel free to try it and as always, feedback is welcome at!

RSS now works on Kimonote!

@kimonote 4 years, 8 months ago | kimonote | announcements | rss |

RSS is now available on all temporary Kimonote streams!

For example, is for all Kimonote posts and is just for announcements.

As always, feel free to follow Kimonote on Twitter, or now, in your favourite RSS reader!

Kimonote demos are now live!

@kimonote 4 years, 8 months ago | kimonote | announcements | demo |

We now have a quick demo available at No registration or email required — just click on the button to get a temporary account!

Kimonote: first post!

@kimonote 4 years, 8 months ago | admin | kimonote | announcements |

This shall be the official Kimonote staff account where development news and announcements will be shared. As of right now, since nothing links to it, there's very little chance it will get indexed at all...

Copyright © 2017–2018 Artjoms Iškovs ( Questions? Comments? Suggestions? Contact