diff --git a/boilerplate/client/package.json b/boilerplate/client/package.json
index 0bf4cf0..74b4f32 100644
--- a/boilerplate/client/package.json
+++ b/boilerplate/client/package.json
@@ -5,7 +5,7 @@
         "clean": "rm -rf node_modules"
     },
     "dependencies": {
-        "@noyainrain/micro": "^0.44"
+        "@noyainrain/micro": "^0.45"
     },
     "devDependencies": {
         "eslint": "~5.15",
diff --git a/boilerplate/requirements.txt b/boilerplate/requirements.txt
index a91c110..faec789 100644
--- a/boilerplate/requirements.txt
+++ b/boilerplate/requirements.txt
@@ -1 +1 @@
-noyainrain.micro ~= 0.44.0
+noyainrain.micro ~= 0.45.0
diff --git a/client/bind.js b/client/bind.js
index 59943ba..e1306c4 100644
--- a/client/bind.js
+++ b/client/bind.js
@@ -435,6 +435,19 @@ micro.bind.transforms = {
         return micro.bind.transforms.format(ctx, n === 1 ? singular : plural, ...args);
     },
 
+    /**
+     * Return a string representation of the given :class:`Date` *date*.
+     *
+     * Alternatively, *date* may be a string parsable by :class:`Date`. *format* is equivalent to
+     * the *options* argument of :meth:`Date.toLocaleString`.
+     */
+    formatDate(ctx, date, format) {
+        if (typeof date === "string") {
+            date = new Date(date);
+        }
+        return date.toLocaleString("en", format);
+    },
+
     /**
      * Project *arr* into the DOM.
      *
diff --git a/client/components/analytics.html b/client/components/analytics.html
index 6443453..f9de12f 100644
--- a/client/components/analytics.html
+++ b/client/components/analytics.html
@@ -12,6 +12,36 @@ <h1>User statistics</h1>
             labels="Users, Actual users, Monthly active users"
         ></micro-chart>
     </section>
+
+    <section>
+        <h1>Referrals</h1>
+        <div class="micro-lgroup">
+            <ul class="micro-timeline" data-content="list referrals.items 'referral'">
+                <template>
+                    <li>
+                        <time
+                            data-date-time="referral.time"
+                            data-content="formatDate referral.time SHORT_DATE_TIME_FORMAT"
+                        ></time>
+                        <a data-href="referral.url" data-content="referral.url"></a>
+                    </li>
+                </template>
+            </ul>
+            <ul data-content="switch referralsComplete false">
+                <template>
+                    <li>
+                        <button
+                            is="micro-button" class="micro-analytics-more-referrals link"
+                            data-run="bind fetchCollection referrals 10"
+                            data-shortcut="new Shortcut 'M'"
+                        >
+                            <i class="fa fa-ellipsis-v"></i> More
+                        </button>
+                    </li>
+                </template>
+            </ul>
+        </div>
+    </section>
 </template>
 <style>
     .micro-analytics-user-statistics {
diff --git a/client/components/analytics.js b/client/components/analytics.js
index 25a44ad..77ba00d 100644
--- a/client/components/analytics.js
+++ b/client/components/analytics.js
@@ -42,7 +42,22 @@ micro.components.analytics.AnalyticsPage = class extends micro.Page {
         this.appendChild(
             document.importNode(ui.querySelector("#micro-analytics-page-template").content, true)
         );
+        this._data = new micro.bind.Watchable({
+            referrals: new micro.Collection("/api/analytics/referrals"),
+            referralsComplete: false
+        });
+        micro.bind.bind(this.children, this._data);
+
         this.contentNode = this.querySelector(".micro-analytics-content");
+        this._data.referrals.events.addEventListener("fetch", () => {
+            this._data.referralsComplete = this._data.referrals.complete;
+        });
+    }
+
+    attachedCallback() {
+        super.attachedCallback();
+        const button = this.querySelector(".micro-analytics-more-referrals");
+        this.ready.when(button.trigger().catch(micro.util.catch));
     }
 };
 document.registerElement("micro-analytics-page", micro.components.analytics.AnalyticsPage);
@@ -168,11 +183,12 @@ micro.components.analytics.Chart = class extends HTMLElement {
             });
 
             if (datasets[0].data.length >= 2) {
-                const from = datasets[0].data[0].t.toLocaleDateString(
-                    "en", micro.SHORT_DATE_FORMAT
+                const from = micro.bind.transforms.formatDate(
+                    null, datasets[0].data[0].t, micro.bind.transforms.SHORT_DATE_FORMAT
                 );
-                const to = datasets[0].data[datasets[0].data.length - 1].t.toLocaleDateString(
-                    "en", micro.SHORT_DATE_FORMAT
+                const to = micro.bind.transforms.formatDate(
+                    null, datasets[0].data[datasets[0].data.length - 1].t,
+                    micro.bind.transforms.SHORT_DATE_FORMAT
                 );
                 const summary = datasets.map(
                     dataset => `${dataset.label}: ${dataset.data[0].y} - ${dataset.data[dataset.data.length - 1].y}`
diff --git a/client/index.js b/client/index.js
index baf9be8..4979dbf 100644
--- a/client/index.js
+++ b/client/index.js
@@ -23,15 +23,6 @@
 micro.util.watchErrors();
 
 micro.LIST_LIMIT = 100;
-micro.SHORT_DATE_FORMAT = {
-    year: "numeric",
-    month: "short",
-    day: "numeric"
-};
-micro.SHORT_DATE_TIME_FORMAT = Object.assign({
-    hour: "2-digit",
-    minute: "2-digit"
-}, micro.SHORT_DATE_FORMAT);
 
 /**
  * Find the first ancestor of *elem* that satisfies *predicate*.
@@ -265,6 +256,14 @@ micro.UI = class extends HTMLBodyElement {
                         this.dispatchEvent(new CustomEvent("user-edit", {detail: {user}}));
                         const settings = await ui.call("GET", "/api/settings");
                         this.dispatchEvent(new CustomEvent("settings-edit", {detail: {settings}}));
+                        if (
+                            document.referrer &&
+                            new URL(document.referrer).origin !== location.origin
+                        ) {
+                            await ui.call(
+                                "POST", "/api/analytics/referrals", {url: document.referrer}
+                            );
+                        }
                     } catch (e) {
                         if (!(e instanceof micro.NetworkError)) {
                             throw e;
@@ -1972,8 +1971,9 @@ micro.ActivityPage = class extends micro.Page {
             let li = document.createElement("li");
             let time = document.createElement("time");
             time.dateTime = event.time;
-            time.textContent =
-                new Date(event.time).toLocaleString("en", micro.SHORT_DATE_TIME_FORMAT);
+            time.textContent = micro.bind.transforms.formatDate(
+                null, event.time, micro.bind.transforms.SHORT_DATE_TIME_FORMAT
+            );
             li.appendChild(time);
             li.appendChild(ui.renderEvent[event.type](event));
             ul.appendChild(li);
@@ -1984,6 +1984,20 @@ micro.ActivityPage = class extends micro.Page {
 };
 
 Object.assign(micro.bind.transforms, {
+    SHORT_DATE_FORMAT: {
+        year: "numeric",
+        month: "short",
+        day: "numeric"
+    },
+
+    SHORT_DATE_TIME_FORMAT: {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit"
+    },
+
     /**
      * Render *markup text* into a :class:`DocumentFragment`.
      *
diff --git a/client/micro.css b/client/micro.css
index 529e8cc..572b295 100644
--- a/client/micro.css
+++ b/client/micro.css
@@ -168,13 +168,13 @@ strong {
 }
 
 .micro-lgroup {
-    list-style: none;
+    margin: var(--micro-size-rm) 0;
 }
 
 .micro-lgroup > ul,
 .micro-lgroup > ol {
-    padding: 0;
     margin: 0;
+    list-style: none;
 }
 
 .micro-icon-title {
diff --git a/client/package.json b/client/package.json
index 1b39f85..cf20686 100644
--- a/client/package.json
+++ b/client/package.json
@@ -1,6 +1,6 @@
 {
     "name": "@noyainrain/micro",
-    "version": "0.44.0",
+    "version": "0.45.0",
     "description": "Toolkit for social micro web apps.",
     "repository": "noyainrain/micro",
     "license": "LGPL-3.0",
diff --git a/client/templates.html b/client/templates.html
index 25aafac..6d48fec 100644
--- a/client/templates.html
+++ b/client/templates.html
@@ -487,15 +487,15 @@ <h1>Edit site settings</h1>
 <template class="micro-activity-page-template">
     <h1>Site activity</h1>
     <p><small><i class='fa fa-eye'></i> Only visible to staff members</small></p>
-    <ul>
-        <li class="micro-lgroup">
-            <ul class="micro-timeline"></ul>
-        </li>
-        <li class="micro-activity-show-more">
-            <button is="micro-button" class="link">
-                <i class="fa fa-ellipsis-v"></i> Show more
-            </button>
-        </li>
+    <div class="micro-lgroup">
+        <ul class="micro-timeline"></ul>
+        <ul>
+            <li class="micro-activity-show-more">
+                <button is="micro-button" class="link">
+                    <i class="fa fa-ellipsis-v"></i> More
+                </button>
+            </li>
+        </ul>
     </ul>
 </template>
 
diff --git a/micro/analytics.py b/micro/analytics.py
index 5db6ad8..6d41bdc 100644
--- a/micro/analytics.py
+++ b/micro/analytics.py
@@ -24,11 +24,15 @@
 from datetime import datetime, timedelta
 import typing
 from typing import Callable, Dict, Iterator, List, Mapping, Optional, cast
+from urllib.parse import urlsplit
 
-from .util import expect_type, parse_isotime
+from . import error
+from .jsonredis import RedisSortedSet
+from .micro import Collection, Object, User
+from .util import expect_type, parse_isotime, randstr
 
 if typing.TYPE_CHECKING:
-    from micro import Application, User
+    from .micro import Application
 
 StatisticFunc = Callable[[datetime], float]
 
@@ -43,6 +47,10 @@ class Analytics:
 
        Statistics over time by topic.
 
+    .. attribute:: referrals
+
+       Referrals from other sites.
+
     .. attribute:: app
 
        Context application.
@@ -57,6 +65,7 @@ def __init__(self, *, definitions: Mapping[str, StatisticFunc] = {},
             **definitions
         } # type: Dict[str, StatisticFunc]
         self.statistics = {topic: Statistic(topic, app=app) for topic in self.definitions}
+        self.referrals = Referrals(app=app)
         self.app = app
 
     def collect_statistics(self, *, _t: datetime = None) -> None:
@@ -88,7 +97,7 @@ def _count_users_active(self, t: datetime) -> float:
         return sum(1 for user in self._actual_users()
                    if t - user.authenticate_time <= timedelta(days=30)) # type: ignore
 
-    def _actual_users(self) -> Iterator['User']:
+    def _actual_users(self) -> Iterator[User]:
         return (user for user in self.app.users[:] # type: ignore
                 if user.authenticate_time - user.create_time >= timedelta(days=1)) # type: ignore
 
@@ -109,14 +118,14 @@ def __init__(self, topic: str, *, app: 'Application') -> None:
         self.app = app
         self._key = 'analytics.statistics.{}'.format(self.topic)
 
-    def get(self, *, user: Optional['User']) -> List['Point']:
+    def get(self, *, user: Optional[User]) -> List['Point']:
         """See :http:get:`/api/analytics/statistics/(topic)`."""
         if not user in self.app.settings.staff: # type: ignore
             raise PermissionError()
         return [Point.parse(json.loads(p.decode())) for p # type: ignore
                 in self.app.r.r.zrange(self._key, 0, -1)] # type: ignore
 
-    def json(self, *, user: 'User' = None) -> Dict[str, object]:
+    def json(self, *, user: User = None) -> Dict[str, object]:
         """See :meth:`micro.JSONifiable.json`."""
         return {'items': [p.json() for p in self.get(user=user)]}
 
@@ -144,3 +153,35 @@ def json(self) -> Dict[str, object]:
 
     def __eq__(self, other: object) -> bool:
         return isinstance(other, Point) and self.t == other.t and self.v == other.v
+
+class Referral(Object):
+    """See :ref:`Referral`."""
+
+    def __init__(self, *, id: str, app: 'Application', url: str, time: str) -> None:
+        super().__init__(id=id, app=app)
+        self.url = url
+        self.time = parse_isotime(time, aware=True)
+
+    def json(self, restricted: bool = False, include: bool = False) -> Dict[str, object]:
+        return {
+            **super().json(restricted=restricted, include=include),
+            'url': self.url,
+            'time': self.time.isoformat()
+        }
+
+class Referrals(Collection[Referral]):
+    """See :ref:`Referrals`."""
+
+    def __init__(self, *, app: 'Application') -> None:
+        super().__init__(RedisSortedSet('analytics.referrals', app.r.r),
+                         check=lambda key: self.app.check_user_is_staff(), app=app) # type: ignore
+
+    def add(self, url: str, *, user: Optional[User]) -> Referral:
+        """See :http:post:`/api/analytics/referrals`."""
+        # pylint: disable=unused-argument; part of API
+        if urlsplit(url).scheme not in {'http', 'https'}:
+            raise error.ValueError('Bad url scheme {}'.format(url))
+        referral = Referral(id=randstr(), app=self.app, url=url, time=self.app.now().isoformat())
+        self.app.r.oset(referral.id, referral)
+        self.app.r.r.zadd(self.ids.key, {referral.id.encode(): -referral.time.timestamp()})
+        return referral
diff --git a/micro/doc/general.inc b/micro/doc/general.inc
index 3486100..c277e9f 100644
--- a/micro/doc/general.inc
+++ b/micro/doc/general.inc
@@ -259,6 +259,40 @@ Statistic data point.
 
    Statistic value.
 
+.. _Referral:
+
+Referral
+^^^^^^^^
+
+Referral from another site.
+
+.. include:: micro/object-attributes.inc
+
+.. describe:: url
+
+   HTTP(S) referrer URL.
+
+.. describe:: time
+
+   Date and time of the referral.
+
+.. _Referrals:
+
+Referrals
+^^^^^^^^^
+
+:ref:`Referral` :ref:`Collection`, latest first.
+
+Only staff members can query the referrals.
+
+.. include:: micro/collection-endpoints.inc
+
+.. http:post:: /api/analytics/referrals
+
+   ``{url}``
+
+   Record a :ref:`Referral` from *url* and return it.
+
 Errors
 ------
 
diff --git a/micro/jsonredis.py b/micro/jsonredis.py
index f2af4a8..8565af8 100644
--- a/micro/jsonredis.py
+++ b/micro/jsonredis.py
@@ -8,8 +8,8 @@
 
 .. data:: ExpectFunc
 
-   Function of the form `expect(obj: T) -> U` which asserts that an object *obj* is of a certain
-   type *U* and raises a :exc:`TypeError` if not.
+   Function of the form `expect(obj: object) -> _T` which asserts that *obj* is of a certain type
+   *_T* and raises a :exc:`TypeError` if not.
 """
 
 import json
@@ -28,7 +28,7 @@
 T = TypeVar('T')
 U = TypeVar('U')
 
-ExpectFunc = Callable[[T], U]
+ExpectFunc = Callable[[object], T]
 
 _ZPOPTIMED_SCRIPT = """\
 redis.replicate_commands()
@@ -96,8 +96,8 @@ def __init__(
         self._cache = WeakValueDictionary() # type: WeakValueDictionary[str, T]
 
     @overload
-    def oget(self, key: str, *, default: None = None, # type: ignore
-             expect: None = None) -> Optional[T]:
+    def oget( # type: ignore
+            self, key: str, *, default: None = None, expect: None = None) -> Optional[T]:
         # pylint: disable=function-redefined,missing-docstring; overload
         pass
     @overload
@@ -105,16 +105,16 @@ def oget(self, key: str, *, default: Union[T, Type[Exception]], expect: None = N
         # pylint: disable=function-redefined,missing-docstring; overload
         pass
     @overload
-    def oget(self, key: str, *, default: None = None, # type: ignore
-             expect: ExpectFunc[T, U]) -> Optional[U]:
+    def oget( # type: ignore
+            self, key: str, *, default: None = None, expect: ExpectFunc[U]) -> Optional[U]:
         # pylint: disable=function-redefined,missing-docstring; overload
         pass
     @overload
-    def oget(self, key: str, *, default: Union[T, Type[Exception]], expect: ExpectFunc[T, U]) -> U:
+    def oget(self, key: str, *, default: Union[T, Type[Exception]], expect: ExpectFunc[U]) -> U:
         # pylint: disable=function-redefined,missing-docstring; overload
         pass
     def oget(self, key: str, default: Union[T, Type[Exception]] = None,
-             expect: ExpectFunc[T, U] = None) -> Union[Optional[T], T, U, Optional[U]]:
+             expect: ExpectFunc[U] = None) -> Union[Optional[T], T, U, Optional[U]]:
         """Return the object at *key*.
 
         If *key* does not exist, *default* is returned. If *default* is an :exc:`Exception`, it is
@@ -148,8 +148,9 @@ def oset(self, key: str, object: T) -> None:
         self.set(key, json.dumps(object, default=self.encode))
 
     @overload
-    def omget(self, keys: Sequence[str], *, default: None = None, # type: ignore
-              expect: None = None) -> List[Optional[T]]:
+    def omget( # type: ignore
+            self, keys: Sequence[str], *, default: None = None,
+            expect: None = None) -> List[Optional[T]]:
         # pylint: disable=function-redefined,missing-docstring; overload
         pass
     @overload
@@ -158,18 +159,19 @@ def omget(self, keys: Sequence[str], *, default: Union[T, Type[Exception]],
         # pylint: disable=function-redefined,missing-docstring; overload
         pass
     @overload
-    def omget(self, keys: Sequence[str], *, default: None = None, # type: ignore
-              expect: ExpectFunc[T, U]) -> List[Optional[U]]:
+    def omget( # type: ignore
+            self, keys: Sequence[str], *, default: None = None,
+            expect: ExpectFunc[U]) -> List[Optional[U]]:
         # pylint: disable=function-redefined,missing-docstring; overload
         pass
     @overload
     def omget(self, keys: Sequence[str], *, default: Union[T, Type[Exception]],
-              expect: ExpectFunc[T, U]) -> List[U]:
+              expect: ExpectFunc[U]) -> List[U]:
         # pylint: disable=function-redefined,missing-docstring; overload
         pass
     def omget(
             self, keys: Sequence[str], default: Union[T, Type[Exception]] = None,
-            expect: ExpectFunc[T, U] = None
+            expect: ExpectFunc[U] = None
         ) -> Union[List[Optional[T]], List[T], List[Optional[U]], List[U]]:
         """Return a list of objects for the given *keys*.
 
@@ -361,7 +363,7 @@ class JSONRedisMapping(Generic[T, U], Mapping[str, T]):
        Function narrowing the type of retrieved objects. May be ``None``.
     """
 
-    def __init__(self, r: JSONRedis[U], map_key: str, expect: ExpectFunc[U, T] = None) -> None:
+    def __init__(self, r: JSONRedis[U], map_key: str, expect: ExpectFunc[T] = None) -> None:
         self.r = r
         self.map_key = map_key
         self.expect = expect
@@ -441,7 +443,7 @@ def redis_range(slc: slice) -> Tuple[int, int]:
         return (1, 0)
     return (0 if slc.start is None else slc.start, -1 if slc.stop is None else slc.stop - 1)
 
-def expect_type(cls: Type[T]) -> ExpectFunc[object, T]:
+def expect_type(cls: Type[T]) -> ExpectFunc[T]:
     """Return a function which asserts that a given *obj* is an instance of *cls*."""
     def _f(obj: object) -> T:
         if not isinstance(obj, cls):
diff --git a/micro/micro.py b/micro/micro.py
index cee6c94..5b0cb56 100644
--- a/micro/micro.py
+++ b/micro/micro.py
@@ -27,7 +27,7 @@
 from smtplib import SMTP
 import sys
 from typing import (AsyncIterator, Awaitable, Callable, Coroutine, Dict, Generic, Iterator, List,
-                    Optional, Sequence, Set, Tuple, Type, TypeVar, Union, cast, overload)
+                    Optional, Set, Tuple, Type, TypeVar, Union, cast, overload)
 from urllib.parse import SplitResult, urlparse, urlsplit
 
 from pywebpush import WebPusher, WebPushException
@@ -39,15 +39,14 @@
 from tornado.ioloop import IOLoop
 from typing_extensions import Protocol
 
-from .analytics import Analytics
 from .error import CommunicationError, ValueError
 from .jsonredis import (ExpectFunc, JSONRedis, JSONRedisSequence, JSONRedisMapping, RedisList,
                         RedisSequence, bzpoptimed)
 from .resource import ( # pylint: disable=unused-import; typing
     Analyzer, HandleResourceFunc, Image, Resource, Video, handle_image, handle_webpage,
     handle_youtube)
-from .util import (OnType, check_email, expect_opt_type, expect_type, parse_isotime, randstr,
-                   run_instant, str_or_none)
+from .util import (Expect, OnType, check_email, expect_opt_type, expect_type, parse_isotime,
+                   randstr, run_instant, str_or_none)
 
 _PUSH_TTL = 24 * 60 * 60
 
@@ -149,6 +148,8 @@ def __init__(
         except builtins.ValueError:
             raise ValueError('redis_url_invalid')
 
+        # pylint: disable=import-outside-toplevel; circular dependency
+        from .analytics import Analytics, Referral
         self.types = {
             'User': User,
             'Settings': Settings,
@@ -157,7 +158,8 @@ def __init__(
             'AuthRequest': AuthRequest,
             'Resource': Resource,
             'Image': Image,
-            'Video': Video
+            'Video': Video,
+            'Referral': Referral
         } # type: Dict[str, Type[JSONifiable]]
         self.user = None # type: Optional[User]
         self.users = Collection(RedisList('users', self.r.r), expect=expect_type(User), app=self)
@@ -721,8 +723,7 @@ class Collection(Generic[O], JSONRedisMapping[O, JSONifiable]):
     def __init__(
             self, ids: RedisSequence, *,
             check: Callable[[Union[int, slice, str]], None] = None,
-            expect: ExpectFunc[JSONifiable, O] = cast(ExpectFunc[JSONifiable, O],
-                                                      expect_type(Object)),
+            expect: ExpectFunc[O] = cast(ExpectFunc[O], expect_type(Object)),
             app: Application) -> None:
         # pylint: disable=function-redefined, super-init-not-called; overload
         pass
@@ -733,8 +734,7 @@ def __init__(self, host: Tuple[Union[Object, Application], str]) -> None:
     def __init__(
             self, *args: object,
             check: Callable[[Union[int, slice, str]], None] = None,
-            expect: ExpectFunc[JSONifiable, O] = cast(ExpectFunc[JSONifiable, O],
-                                                      expect_type(Object)),
+            expect: ExpectFunc[O] = cast(ExpectFunc[O], expect_type(Object)),
             **kwargs: object) -> None:
         # pylint: disable=function-redefined, super-init-not-called; overload
         # Compatibility for host (deprecated since 0.24.0)
@@ -1389,15 +1389,14 @@ def __init__(self, name: str, coords: Tuple[float, float] = None) -> None:
     @staticmethod
     def parse(data: Dict[str, object]) -> 'Location':
         """Parse the given location JSON *data* into a :class:`Location`."""
-        name, coords = data.get('name'), data.get('coords')
-        if not isinstance(name, str):
-            raise TypeError()
-        if coords is not None:
-            if not (isinstance(coords, Sequence) and len(coords) == 2 and
-                    all(isinstance(value, (float, int)) for value in coords)):
+        coords_list = Expect.opt(Expect.list(Expect.float))(data.get('coords'))
+        if coords_list is None:
+            coords = None
+        else:
+            if len(coords_list) != 2:
                 raise TypeError()
-            coords = (float(coords[0]), float(coords[1]))
-        return Location(name, coords)
+            coords = (float(coords_list[0]), float(coords_list[1]))
+        return Location(Expect.str(data.get('name')), coords)
 
     def json(self) -> Dict[str, object]:
         """Return a JSON representation of the location."""
diff --git a/micro/resource.py b/micro/resource.py
index 930e154..999fcee 100644
--- a/micro/resource.py
+++ b/micro/resource.py
@@ -34,7 +34,7 @@
 
 from . import error
 from .error import CommunicationError, Error
-from .util import expect_opt_type, expect_type, str_or_none
+from .util import Expect, expect_type, str_or_none
 from .webapi import WebAPI, fetch
 
 HandleResourceFunc = Callable[[str, str, bytes, 'Analyzer'],
@@ -48,9 +48,9 @@ def parse(data: Dict[str, object], **args: object) -> 'Resource':
         """See :meth:`JSONifiableWithParse.parse`."""
         # pylint: disable=unused-argument; part of API
         return Resource(
-            expect_type(str)(data['url']), expect_type(str)(data['content_type']),
-            description=expect_opt_type(str)(data['description']),
-            image=expect_opt_type(Image)(data['image']))
+            Expect.str(data.get('url')), Expect.str(data.get('content_type')),
+            description=Expect.opt(Expect.str)(data.get('description')),
+            image=Expect.opt(expect_type(Image))(data.get('image')))
 
     def __init__(self, url: str, content_type: str, *, description: str = None,
                  image: 'Image' = None) -> None:
diff --git a/micro/server.py b/micro/server.py
index 74be335..93a4580 100644
--- a/micro/server.py
+++ b/micro/server.py
@@ -22,6 +22,7 @@
                      get_event_loop, ensure_future)
 from collections.abc import Mapping
 from functools import partial
+from http import HTTPStatus
 import http.client
 import json
 from logging import getLogger
@@ -29,7 +30,8 @@
 from pathlib import Path
 import re
 from signal import SIGINT
-from typing import Callable, ClassVar, Dict, List, Optional, Sequence, Tuple, Type, Union, cast
+from typing import (Callable, ClassVar, Dict, List, Optional, Sequence, Tuple, Type, TypeVar, Union,
+                    cast)
 from urllib.parse import urljoin, urlparse
 
 from mypy_extensions import TypedDict, VarArg
@@ -44,7 +46,8 @@
     Activity, AuthRequest, Collection, JSONifiable, Object, User, InputError, AuthenticationError,
     CommunicationError, PermissionError)
 from .resource import NoResourceError, ForbiddenResourceError, BrokenResourceError
-from .util import cancel, look_up_files, str_or_none, parse_slice, check_polyglot
+from .util import (Expect, ExpectFunc, cancel, look_up_files, str_or_none, parse_slice,
+                   check_polyglot)
 
 LIST_LIMIT = 100
 SLICE_URL = r'(?:/(\d*:\d*))?'
@@ -60,11 +63,18 @@
 
 _LOGGER = getLogger(__name__)
 
+class _UndefinedType:
+    pass
+_UNDEFINED = _UndefinedType()
+
 Handler = Union[Tuple[str, Type[RequestHandler]],
                 Tuple[str, Type[RequestHandler], Dict[str, object]]]
 
 _ApplicationSettings = TypedDict('_ApplicationSettings', # pylint: disable=invalid-name; type alias
                                  {'static_path': str, 'server': 'Server'})
+
+_T = TypeVar('_T')
+
 class Server:
     """Server for micro apps.
 
@@ -237,6 +247,7 @@ def get_activity(*args: str) -> Activity:
             (r'/api/activity/stream', ActivityStreamEndpoint,
              {'get_activity': cast(object, get_activity)}),
             (r'/api/analytics/statistics/([^/]+)$', _StatisticEndpoint),
+            (r'/api/analytics/referrals$', _ReferralsEndpoint),
             *handlers,
             # UI
             (r'/log-client-error$', _LogClientErrorEndpoint),
@@ -392,6 +403,21 @@ def log_exception(self, typ, value, tb):
             return
         super().log_exception(typ, value, tb)
 
+    def get_arg(self, name: str, expect: ExpectFunc[_T], *,
+                default: Union[_T, _UndefinedType] = _UNDEFINED) -> _T:
+        """Return the argument with the given *name*, asserting its type with *expect*.
+
+        If the argument does not exist, *default* is returned. If the argument has an unexpected
+        type or is missing with no *default*, a :exc:`micro.error.ValueError` is raised.
+        """
+        arg = self.args.get(name, default)
+        if arg is _UNDEFINED:
+            raise error.ValueError('Missing {}'.format(name))
+        try:
+            return expect(arg)
+        except TypeError:
+            raise error.ValueError('Bad {} type'.format(name))
+
     def check_args(self, type_info):
         """Check *args* for their expected type.
 
@@ -898,3 +924,13 @@ class _StatisticEndpoint(Endpoint):
     def get(self, topic: str) -> None:
         statistic = self.app.analytics.statistics[topic]
         self.write(statistic.json(user=self.current_user))
+
+class _ReferralsEndpoint(CollectionEndpoint):
+    def initialize(self, **args: object) -> None:
+        super().initialize(get_collection=lambda: self.app.analytics.referrals, **args)
+
+    def post(self) -> None:
+        url = self.get_arg('url', Expect.str)
+        referral = self.app.analytics.referrals.add(url, user=self.current_user)
+        self.set_status(HTTPStatus.CREATED) # type: ignore
+        self.write(referral.json(restricted=True, include=True))
diff --git a/micro/tests/test_analytics.py b/micro/tests/test_analytics.py
index 49405c4..1fd33de 100644
--- a/micro/tests/test_analytics.py
+++ b/micro/tests/test_analytics.py
@@ -56,3 +56,9 @@ def test_collect_statistics(self, now) -> None:
                          users_actual)
         self.assertEqual(self.app.analytics.statistics['users-active'].get(user=self.staff_member),
                          users_active)
+
+class ReferralsTest(MicroTestCase):
+    def test_add(self) -> None:
+        referral = self.app.analytics.referrals.add('https://example.org/', user=self.user)
+        self.assertEqual(referral.url, 'https://example.org/')
+        self.assertIn(referral.id, self.app.analytics.referrals)
diff --git a/micro/tests/test_server.py b/micro/tests/test_server.py
index ac65051..694fed0 100644
--- a/micro/tests/test_server.py
+++ b/micro/tests/test_server.py
@@ -57,6 +57,8 @@ async def test_availability(self):
         await self.request('/api/users/{}'.format(self.app.user.id), method='PATCH',
                            body='{"op": "disable_notifications"}')
         await self.request('/api/settings')
+        await self.request('/api/analytics/referrals', method='POST',
+                           body='{"url": "https://example.org/"}')
 
         # API (generic)
         cat = self.app.cats.create()
@@ -74,6 +76,7 @@ async def test_availability(self):
         await self.request('/api/activity/v2', method='PATCH', body='{"op": "subscribe"}')
         await self.request('/api/activity/v2', method='PATCH', body='{"op": "unsubscribe"}')
         await self.request('/api/analytics/stats/users')
+        await self.request('/api/analytics/referrals')
 
     @gen_test
     def test_endpoint_request(self):
diff --git a/micro/util.py b/micro/util.py
index 06ba83f..90b5081 100644
--- a/micro/util.py
+++ b/micro/util.py
@@ -22,10 +22,12 @@
 import argparse
 from argparse import ArgumentParser
 from asyncio import CancelledError, Task # pylint: disable=unused-import; typing
+import builtins
 from collections import OrderedDict
 from datetime import datetime, timezone
 import logging
 from logging import StreamHandler, getLogger
+from numbers import Real
 from os import walk
 from pathlib import Path
 import random
@@ -44,6 +46,7 @@ class OnType:
 ON = OnType()
 
 _T = TypeVar('_T')
+_U = TypeVar('_U')
 
 def str_or_none(str: str) -> Optional[str]:
     """Return *str* unmodified if it has content, otherwise return ``None``.
@@ -204,7 +207,7 @@ def run_instant(coro: Coroutine[object, object, _T]) -> _T:
     except StopIteration as e:
         return cast(_T, e.value)
 
-def expect_opt_type(cls: Type[_T]) -> ExpectFunc[Optional[object], Optional[_T]]:
+def expect_opt_type(cls: Type[_T]) -> ExpectFunc[Optional[_T]]:
     """Return a function that asserts a given *obj* is an instance of *cls* or ``None``."""
     def _f(obj: Optional[object]) -> Optional[_T]:
         if obj is not None and not isinstance(obj, cls):
@@ -243,3 +246,39 @@ def _decorator(func):
         versions[v] = func
         return _wrapper
     return _decorator
+
+class Expect:
+    """Compilation of type assertions.
+
+    .. attribute:: str
+
+       Assert that *obj* is a :class:`str`.
+
+    .. attribute:: float
+
+       Assert that *obj* is a :class:`float`.
+    """
+
+    str = expect_type(builtins.str)
+    float = expect_type(Real) # type: ignore
+
+    @staticmethod
+    def list(expect_item: ExpectFunc[_T]) -> ExpectFunc[List[_T]]:
+        """Return a function that asserts *obj* is a :class:`list`.
+
+        The type of each item is asserted with *expect_item*.
+        """
+        def _f(obj: object) -> List[_T]:
+            if not isinstance(obj, builtins.list):
+                raise TypeError()
+            for item in obj:
+                expect_item(item)
+            return obj
+        return _f
+
+    @staticmethod
+    def opt(expect: ExpectFunc[_T]) -> ExpectFunc[Optional[_T]]:
+        """Return a function that asserts *obj* is ``None`` or meets *expect*."""
+        def _f(obj: object) -> Optional[_T]:
+            return None if obj is None else expect(obj)
+        return _f
diff --git a/setup.py b/setup.py
index 6ba92bf..abb5b03 100644
--- a/setup.py
+++ b/setup.py
@@ -7,7 +7,7 @@
 
 setup(
     name='noyainrain.micro',
-    version='0.44.0',
+    version='0.45.0',
     url='https://github.com/noyainrain/micro',
     maintainer='Sven James',
     maintainer_email='sven@inrain.org',