Caldav sync for Emacs Orgmode
Minimum Emacs version needed: 26.3
- Owncloud and Nextcloud: Regularly tested.
- Google Calendar: Should work, but you need to register an application with the Google Developer Console for OAuth2 authentication (see below), because Google explicitly forbids to put client id/secrets into open source software (see https://developers.google.com/terms, section 4b, paragraph 1). Instead of doing that though, I’d rather suggest you choose another service provider.
- Radicale and Baikal: Should work. If you get problems with
‘Digest’ authentication, switch back to ‘Basic’ (make sure to use
https, though!). If you get asked for password repeatedly, put it in
.authinfofile (see below).
- SOGo and Kolab: Reported to be working (https://kolabnow.com/clients/emacs)
Note that Emacs releases <26.3 might not correctly handle https via TLSv1.3 (see https://debbugs.gnu.org/cgi/bugreport.cgi?bug=34341). If you see errors like “Bad request” or “No data received” you can either try to set
(setq gnutls-algorithm-priority "NORMAL:-VERS-TLS1.3")
or you upgrade to Emacs 26.3.
IMPORTANT: Before using this code, please make sure you have backups of your precious Org files. Also, I strongly suggest to create a new, empty calendar on your server for using this package.
ALSO IMPORTANT: When using this package, possibly all Org entries will
get an UID property (see the docstring of
further details). If you don’t want this, then do not use this
package; there is just no way around that. It is the only reliable way
to uniquely identify Org entries.
IN A NUTSHELL
- Create a new calendar; the name does not matter.
org-caldav-urlto the base address of your CalDAV server:
- Owncloud/Nextcloud (9.x and above): https://OWNCLOUD-SERVER-URL/remote.php/dav/calendars/USERID
- Google: Set to symbol ~’google~. See below for further documentation.
org-caldav-calendar-idto the calendar ID of your new calendar:
- Own/NextCloud: Click on that little symbol next to the calendar name and inspect the link of the calendar; the last element of the shown path is the calendar-id. This should usually be the same as the name of the calendar, but not necessarily: Owncloud might replace certain characters (upper to lowercase, for instance), or it might even be entirely different if the calendar was created by another CalDAV application.
- Google: Click on ‘calendar settings’ and the id will be shown next
to “Calendar Address”. It is of the form
ID@group.calendar.google.com. Do not omit the domain!
org-caldav-inboxto an org filename where new entries from the calendar should be stored. Just to be safe, I suggest using an empty, dedicated Org file for that.
org-caldav-filesto the list of org files you would like to sync. The above
org-caldav-inboxwill be automatically added, so you don’t have to add it here.
- It is usually a good idea to manually set
org-icalendar-timezoneto the timezone of your remote calendar. It should be a simple string like “Europe/Berlin”. If that doesn’t work and your events are shifted by a few hours, try the setting “UTC” (the SOGo calendar server seems to need this).
Please note that org-caldav does not directly control how and which
entries are exported, it just uses the org-icalendar
exporter. Therefore, you should also take a look at the options from
the org-icalendar exporter. Most importantly, take a look at
org-icalendar-alarm-time to add a reminder to your entries, and
org-icalendar-use-scheduled to control
which timestamps should be used.
org-caldav-sync to start the sync. The
url package will ask you
for username/password for accessing the calendar. (See below on how to
store that password in an authinfo file.)
The first sync can easily take several minutes, depending on the
number of calendar items. Especially Google’s CalDAV interface is
pretty slow. If you have to abort the initial sync for some reason,
org-caldav-sync again in the same Emacs session and you
should get asked if you’d like to resume.
The same goes for sync errors you might get. Especially when using
Google Calendar, it is not unusual to get stuff like ‘409’ errors
during the initial sync. Only Google knows why. Just run
org-caldav-sync again until all events are uploaded.
Syncing to Google Calendar
The new CalDAV endpoint for Google Calendar requires OAuth2 authentication. So first, you need to install the oauth2 library from GNU ELPA, and afterwards you need to acquire an application ID and secret from the Google Developer Console. For details on how to do this, follow the Google documentation at
Put the client ID and secret into
org-caldav-oauth2-client-secret, respectively. Then set
org-caldav-url to the symbol ~’google~, and look up the
org-caldav-calendar-id as described above.
On first connection, the oauth2 library should redirect you to the
browser, so make sure that
browse-url-browser-function is set to
browse-url-firefox (the internal eww or w3m browsers
will not work). After authentication, you will be given a key that
you have to paste into the Emacs prompt. The oauth2 library will save
this key in Emacs’ secure plist store, which is encrypted with
GnuPG. If you have not yet used a secure plist store, you will be
asked for its encryption passphrase. In the future, you should only
need to enter that passphrase again to connect with Google Calendar.
By default, plstore will not cache your entered password, so it will possibly ask you many times. To activate caching, use
(setq plstore-cache-passphrase-for-symmetric-encryption t)
Compared to earlier versions of this package from 2012, it now does
proper two-way syncing, that means it does not matter where and how
you change an entry. You can also move Org entries freely from one
file to another, as long as they are all listed in
org-caldav-files. The org-icalendar package will put a unique ID on
each entry with an active timestamp, so that org-caldav can find
it. It will also sync deletions, but more on that later.
You can also return to the simpler version which only does one-way
syncing. Simply set
org-caldav-sync-direction to ~’org->cal~ or
~’cal->org~, depending on which direction you’d like to have. If you
choose ~’org->cal~, then
org-caldav-inbox won’t matter and can be
nil. Likewise, if you choose ~’cal->org~, then
will be ignored and only the calendar will be imported into the inbox.
Org and the iCalendar format
An Org entry can store much more information than an iCalendar entry, so there is no one-to-one correspondence between the two formats which makes syncing a bit difficult.
- Org to iCalendar
This package uses the org-icalendar package to do the export to the
iCalendar format (.ics files). By default, it uses the title of the
Org entry as SUMMARY and puts the entry’s body into DESCRIPTION,
snipping stuff like properties and timestamps (you can override that
with properties of the same name, but IMO it makes stuff just more
complicated). The variable
denotes how many characters from the body should be included as
DESCRIPTION (by default all characters are included).
- iCalendar to Org
If you create a new iCalendar entry in your calendar, you’ll get an
Org entry with SUMMARY as heading, DESCRIPTION as body and the
timestamp. However, if you change an existing entry in the calendar,
things get more complicated and the variable
org-caldav-sync-changes-to-org comes into play. Its default is the
symbol “title-and-timestamp”, which means that only the entry’s
heading is synced (with SUMMARY) and the timestamp gets updated, but
not the entry’s body with DESCRIPTION. The simple reason is that
you might loose data, since DESCRIPTION is rather limited in what it
can store. Still, you can set the variable to the symbol “all”, which
will completely replace an existing Org entry with the entry that
gets generated from the calendar’s event. You can also limit syncing
to heading and/or timestamp only.
To be extra safe, org-caldav will by default backup entries it
changes. See the variable
org-caldav-backup-file for details.
- Org sexp entries
A special case are sexp entries like
%%(diary-anniversary 2 2 1969) Foo's birthday * Regular meeting <%%(diary-float t 4 2)>
As you can see, they can appear in two different ways: plain by themselves, or inside an Org entry. If they are inside an Org entry, there’s a good chance they will be exported (see below) and have an ID property, so they can be found by org-caldav. We can sync the title, but syncing the timestamp with the s-expression is just infeasible, so this will generate a sync error (which are not critical; you’ll just see them at the end of the sync, just so that you’re aware that some stuff wasn’t synced properly).
However, sexp-entries are insanely flexible, and there are limits as to what the icalendar exporter will handle. For example, this here
** Regular event <%%(memq (calendar-day-of-week date) '(1 3 5))>
will not be exported at all.
If the sexp entry is not inside an Org entry but stands by itself,
they still will be exported, but they won’t get an ID (since IDs are
properties linked to Org entries). In practice, that means that you
can delete and change them inside Org and this will be synced, but if
you change them in the calendar, this will not get synced
back. Org-caldav just cannot find those entries, so this will generate
a one-time sync error instead (again: those are not critical, just
FYI). If you don’t want those entries to be exported at all, just set
org-icalendar-include-sexps to nil.
There are several possibilities to choose which entries should be synced and which not:
- If you only want to sync manually marked entries, use
org-caldav-select-tags, which is directly mapped to
org-export-select-tags, so see its doc-string on how it works.
- If you want to exclude certain tags, use
org-caldav-exclude-tags, which is mapped to
- If you want more fine grained control, use
org-caldav-skip-conditions. The syntax of the conditions is described in the doc-string of
- In case you just want to keep your remote calendar clean, set
org-caldav-days-in-pastto the number of days you want to keep in the past on the remote calendar. This does not affect your org files, it works just as a filter for entries older than N days.
Note however that the normal
not have any effect on the icalendar exporter (this used to be the
case, but changed with the new exporters).
If you delete entries in your Org files, the corresponding iCalendar
entries will by default get deleted. You can change that behavior with
org-caldav-delete-calendar-entries to never delete, or to ask before
You must be careful to not simply remove previously synced files from
org-caldav-files, as org-caldav would view all the entries from those
files as deleted and hence by default also delete them from the
calendar. However, org-caldav should be able to detect this situation
and warn you with the message ‘Previously synced file(s) are missing’,
asking you whether to continue nonetheless.
If you delete events in your calendar, you will by default get asked
if you’d like to delete the corresponding Org event. You can change
that behavior through
If you answer a deletion request with “no”, the event should get
re-synced to the calendar next time you call
Now that’s an easy one: Org always wins. That means, if you change an entry in Org and in the calendar, the changes in the calendar will be lost. I might implement proper conflict handling some day, but don’t hold your breath (patches are welcome, of course).
Storing authentication information in authinfo/netrc
If you don’t want to enter your user/password every time, you can store it permanently in an authinfo file. In Emacs, the auth-source package takes care of that, but the syntax for https authentication is a bit peculiar. You have to use a line like the following
machine www.google.com:443 port https login username password secret
Note that you have to specify the port number in the URL and also specify ‘https’ for the port. This is not a bug. For more information, see (info “auth”), especially section “Help for users”.
Since you are storing your password in a file you should encrypt it using GnuPG. Emacs will prompt you for a decryption key when it tries to read the file.
Storage of sync information and sync from different computers
The current sync state is stored in a file
/.emacs.d directory. You can change the location through the
variable ~org-caldav-save-directory. SOMEID directly depends on the
calendar id (it’s a snipped MD5).
If you sync your Org files across different machines and want to use
org-caldav on all of them, don’t forget to sync the org sync state,
too. Probably your best bet is to set
org-caldav-save-directory to the
path you have your Org files in, so that it gets copied alongside with
Starting from scratch
If your sync state somehow gets broken, you can make a clean slate by doing
C-u M-x org-caldav-delete-everything
The function has to be called with a prefix so that you don’t call it
by accident. This will delete everything in the calendar along with
the current sync state. You can then call
and it will completely put all Org events into the now empty
calendar. Needless to say, don’t do that if you have new events in
your calendar which are not synced yet…
Deleting many events can be slow, though; in that case, just delete the calendar and re-create it, delete the sync state file in ~/.emacs.d and restart Emacs.
Syncing with more than one calendar
This can be done by setting the variable
should be a list of plists (a ‘plist’ is simply a list with alternating
:key’s and values). Through these plists, you can override the global
values of variables like
org-caldav-calendar-id, and calling
org-caldav-sync will go through these plists in order.
(setq org-caldav-calendars '((:calendar-id "work@whatever" :files ("~/org/work.org") :inbox "~/org/fromwork.org") (:calendar-id "stuff@mystuff" :files ("~/org/sports.org" "~/org/play.org") :skip-conditions (regexp "soccer") :inbox "~/org/fromstuff.org")) )
This means that you have two calendars with IDs “work@whatever” and
“stuff@mystuff”. Both will be accessed through the global value of
org-caldav-url, since the key :url isn’t specified. The calendar
“work@whatever” will be synced with the file ‘work.org’ and inbox
‘fromwork.org’, while “stuff@mystuff” with ‘sports.org’ and
‘play.org’, unless there’s the string ‘soccer’ in the heading, and
and inbox is ‘fromstuff.org’. See the doc-string of
org-caldav-calendars for more details on which keys you can use.
Customizing the inbox
See the doc-string of
org-caldav-inbox if you want more flexibility in
where new items should be put. Instead of simply providing a file, you
can also choose an existing entry or headline, or put the entry under a
Timezone handling is plain horrible, and it seems every CalDAV server
does it slightly differently, also using non-standard headers like
X-WR-TIMEZONE. If you see items being shifted by a few hours, make
really really sure you have properly set
that your calendar is configured to use the same one.
If it still does not work, you can try setting
to the string “UTC”. This will put all events using UTC times and the
server should transpose the time to the timezone you have set in your
calendar preferences. For some servers (like SOGo) this might work
better than setting a “real” timezone.
If org-caldav reports a problem with the given URL, please triple-check that the URL is correct. It must point to a valid calendar on your CalDAV server.
If the error is that the URL does not seem to accept DAV requests, you can additionally check with ‘curl’ by doing
curl -D - -X OPTIONS --basic -u mylogin:mypassword URL
The output of this command must contain a ‘DAV’ header like this:
DAV: 1, 3, extended-mkcol, access-control, ... etc. ...
By default, org-caldav will put all kinds of debug output into the
*org-caldav-debug*. Look there if you’re getting sync errors
or if something plain doesn’t work. If you’re using an authinfo file
and authentication doesn’t work, set auth-info-debug to t and look in
*Messages* buffer. When you report a bug, please try to post the
relevant portion of the
*org-caldav-debug* buffer since it might be
helpful to see what’s going wrong. If Emacs throws an error, do
and try to replicate the error to get a backtrace.
You can also turn on excessive debugging by setting the variable
org-caldav-debug-level to 2. This will also output the contents of
the events into the debug buffer. If you send such a buffer in a bug
report, please make very sure you have removed personal information
from those events.
Syncing TODOs between Org and CalDav
This feature is relatively new and less well tested, so it is recommended to have backups before using it. It has been tested on nextcloud and radicale.
To sync TODO’s between Org and the CalDav server, do:
(setq org-icalendar-include-todo 'all org-caldav-sync-todo t)
The first instructs the Org exporter to include TODOs; the second tells org-caldav to import icalendar VTODOs as Org TODOs.
Other customizations to consider (see their documentation for more details):
org-caldav-todo-priorityto control how priority levels map between iCalendar and Org.
org-caldav-todo-percent-statesto convert between
org-todo-keywordsand iCalendar’s percent-complete property.
org-caldav-todo-deadline-schedule-warning-daysto auto-create SCHEDULED timestamps when a DEADLINE is present (this might be useful for users of the OpenTasks app).
If you find that some Org entries get an extra tag which equals their CATEGORY, this might be caused by the CATEGORY being exported to iCalendar, and then re-imported to Org as a tag. In that case, do
(setq org-icalendar-categories '(local-tags))
to prevent the CATEGORY from being exported to iCalendar. This problem only seems to affect some CalDav servers: in particular, NextCloud is affected, but Radicale does not seem to experience this problem.
- Recurring events created or changed on the calendar side cannot be synced (they will work fine as long as you manage them in Org, though).
- Syncing is currently pretty slow since everything is done synchronously.
- Pretty much everything besides SUMMARY, DESCRIPTION, LOCATION and time is ignored in iCalendar.
How syncing happens (a.k.a. my little CalDAV rant)
(This is probably not interesting, so you can just stop reading.)
CalDAV is a mess.
First off, it is based on WebDAV, which has its own fair share of problems. The main design flaw of CalDAV however, is that UID and resource name (the “filename”, if you want) are two different things. I know that there are reasons for that (not everything has a UID, like timezones, and you can put several events in one resource), but this is typical over-engineering to allow some marginal use cases pretty much no one needs. Another problem is that you have to do additional round-trips to get Etag and sequence number, which makes CalDAV pretty slow.
Org-caldav takes the easy route: it assumes that every resource contains one event, and that UID and resource name are identical. In fact, Google’s CalDAV interface even enforces the latter. And while Owncloud does not enforce it, at least it just does it if you create items in its web interface.
However, the CalDAV standard does not demand this, so I guess there are servers out there with which org-caldav does not work. Patches welcome.
Now, all this would be bad enough if it weren’t for the sloppy server implementations which make implementing a CalDAV client a living hell and led to several rewrites of the code. Especially Google, the 500 pound gorilla in the room, doesn’t really care much for CalDAV. I guess they really like their own shiny REST-based calendar API better, and I can’t blame them for that.