diff --git a/swh/web/api/views/release.py b/swh/web/api/views/release.py
index 36d0a8a9..60a07b6a 100644
--- a/swh/web/api/views/release.py
+++ b/swh/web/api/views/release.py
@@ -1,60 +1,60 @@
 # Copyright (C) 2015-2019  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from swh.web.api import utils
 from swh.web.api.apidoc import api_doc, format_docstring
 from swh.web.api.apiurls import api_route
 from swh.web.api.views.utils import api_lookup
 from swh.web.common import archive
 
 
 @api_route(
     r"/release/(?P<sha1_git>[0-9a-f]+)/", "api-1-release", checksum_args=["sha1_git"]
 )
 @api_doc("/release/")
 @format_docstring()
 def api_release(request, sha1_git):
     """
     .. http:get:: /api/1/release/(sha1_git)/
 
         Get information about a release in the archive. Releases are identified
         by **sha1** checksums, compatible with Git tag identifiers. See
         :func:`swh.model.git_objects.release_git_object` in our data model
         module for details about how they are computed.
 
         :param string sha1_git: hexadecimal representation of the release
             **sha1_git** identifier
 
         {common_headers}
 
         :>json object author: information about the author of the release
-        :>json string date: ISO representation of the release date (in UTC)
+        :>json string date: RFC3339 representation of the release date
         :>json string id: the release unique identifier
         :>json string message: the message associated to the release
         :>json string name: the name of the release
         :>json string target: the target identifier of the release
         :>json string target_type: the type of the target, can be either
             **release**, **revision**, **content**, **directory**
         :>json string target_url: a link to the adequate api url based on the
             target type
 
         :statuscode 200: no error
         :statuscode 400: an invalid **sha1_git** value has been provided
         :statuscode 404: requested release can not be found in the archive
 
         **Example:**
 
         .. parsed-literal::
 
             :swh_web_api:`release/208f61cc7a5dbc9879ae6e5c2f95891e270f09ef/`
     """
     error_msg = "Release with sha1_git %s not found." % sha1_git
     return api_lookup(
         archive.lookup_release,
         sha1_git,
         notfound_msg=error_msg,
         enrich_fn=utils.enrich_release,
         request=request,
     )
diff --git a/swh/web/api/views/revision.py b/swh/web/api/views/revision.py
index 5a54b057..dd941c45 100644
--- a/swh/web/api/views/revision.py
+++ b/swh/web/api/views/revision.py
@@ -1,215 +1,214 @@
 # Copyright (C) 2015-2019  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from django.http import HttpResponse
 
 from swh.web.api import utils
 from swh.web.api.apidoc import api_doc, format_docstring
 from swh.web.api.apiurls import api_route
 from swh.web.api.views.utils import api_lookup
 from swh.web.common import archive
 
 DOC_RETURN_REVISION = """
         :>json object author: information about the author of the revision
         :>json object committer: information about the committer of the
             revision
-        :>json string committer_date: ISO representation of the commit date
-            (in UTC)
-        :>json string date: ISO representation of the revision date (in UTC)
+        :>json string committer_date: RFC3339 representation of the commit date
+        :>json string date: RFC3339 representation of the revision date
         :>json string directory: the unique identifier that revision points to
         :>json string directory_url: link to
             :http:get:`/api/1/directory/(sha1_git)/[(path)/]` to get
             information about the directory associated to the revision
         :>json string id: the revision unique identifier
         :>json boolean merge: whether or not the revision corresponds to a
             merge commit
         :>json string message: the message associated to the revision
         :>json array parents: the parents of the revision, i.e. the previous
             revisions that head directly to it, each entry of that array
             contains an unique parent revision identifier but also a link to
             :http:get:`/api/1/revision/(sha1_git)/` to get more information
             about it
         :>json string type: the type of the revision
 """
 
 DOC_RETURN_REVISION_ARRAY = DOC_RETURN_REVISION.replace(":>json", ":>jsonarr")
 
 
 @api_route(
     r"/revision/(?P<sha1_git>[0-9a-f]+)/", "api-1-revision", checksum_args=["sha1_git"]
 )
 @api_doc("/revision/")
 @format_docstring(return_revision=DOC_RETURN_REVISION)
 def api_revision(request, sha1_git):
     """
     .. http:get:: /api/1/revision/(sha1_git)/
 
         Get information about a revision in the archive. Revisions are
         identified by **sha1** checksums, compatible with Git commit
         identifiers.
         See :func:`swh.model.git_objects.revision_git_object` in our data model
         module for details about how they are computed.
 
         :param string sha1_git: hexadecimal representation of the revision
             **sha1_git** identifier
 
         {common_headers}
 
         {return_revision}
 
         :statuscode 200: no error
         :statuscode 400: an invalid **sha1_git** value has been provided
         :statuscode 404: requested revision can not be found in the archive
 
         **Example:**
 
         .. parsed-literal::
 
             :swh_web_api:`revision/aafb16d69fd30ff58afdd69036a26047f3aebdc6/`
     """
     return api_lookup(
         archive.lookup_revision,
         sha1_git,
         notfound_msg="Revision with sha1_git {} not found.".format(sha1_git),
         enrich_fn=utils.enrich_revision,
         request=request,
     )
 
 
 @api_route(
     r"/revision/(?P<sha1_git>[0-9a-f]+)/raw/",
     "api-1-revision-raw-message",
     checksum_args=["sha1_git"],
 )
 @api_doc("/revision/raw/", tags=["hidden"])
 def api_revision_raw_message(request, sha1_git):
     """Return the raw data of the message of revision identified by sha1_git
     """
     raw = archive.lookup_revision_message(sha1_git)
     response = HttpResponse(raw["message"], content_type="application/octet-stream")
     response["Content-disposition"] = "attachment;filename=rev_%s_raw" % sha1_git
     return response
 
 
 @api_route(
     r"/revision/(?P<sha1_git>[0-9a-f]+)/directory/",
     "api-1-revision-directory",
     checksum_args=["sha1_git"],
 )
 @api_route(
     r"/revision/(?P<sha1_git>[0-9a-f]+)/directory/(?P<dir_path>.+)/",
     "api-1-revision-directory",
     checksum_args=["sha1_git"],
 )
 @api_doc("/revision/directory/")
 @format_docstring()
 def api_revision_directory(request, sha1_git, dir_path=None, with_data=False):
     """
     .. http:get:: /api/1/revision/(sha1_git)/directory/[(path)/]
 
         Get information about directory (entry) objects associated to revisions.
         Each revision is associated to a single "root" directory.
         This endpoint behaves like :http:get:`/api/1/directory/(sha1_git)/[(path)/]`,
         but operates on the root directory associated to a given revision.
 
         :param string sha1_git: hexadecimal representation of the revision
             **sha1_git** identifier
         :param string path: optional parameter to get information about the
             directory entry pointed by that relative path
 
         {common_headers}
 
         :>json array content: directory entries as returned by
             :http:get:`/api/1/directory/(sha1_git)/[(path)/]`
         :>json string path: path of directory from the revision root one
         :>json string revision: the unique revision identifier
         :>json string type: the type of the directory
 
         :statuscode 200: no error
         :statuscode 400: an invalid **sha1_git** value has been provided
         :statuscode 404: requested revision can not be found in the archive
 
         **Example:**
 
         .. parsed-literal::
 
             :swh_web_api:`revision/f1b94134a4b879bc55c3dacdb496690c8ebdc03f/directory/`
     """
     rev_id, result = archive.lookup_directory_through_revision(
         {"sha1_git": sha1_git}, dir_path, with_data=with_data
     )
 
     content = result["content"]
     if result["type"] == "dir":  # dir_entries
         result["content"] = [
             utils.enrich_directory_entry(entry, request=request) for entry in content
         ]
     elif result["type"] == "file":  # content
         result["content"] = utils.enrich_content(content, request=request)
     elif result["type"] == "rev":  # revision
         result["content"] = utils.enrich_revision(content, request=request)
 
     return result
 
 
 @api_route(
     r"/revision/(?P<sha1_git>[0-9a-f]+)/log/",
     "api-1-revision-log",
     checksum_args=["sha1_git"],
 )
 @api_doc("/revision/log/")
 @format_docstring(return_revision_array=DOC_RETURN_REVISION_ARRAY)
 def api_revision_log(request, sha1_git):
     """
     .. http:get:: /api/1/revision/(sha1_git)/log/
 
         Get a list of all revisions heading to a given one, in other words show
         the commit log.
 
         The revisions are returned in the breadth-first search order while
         visiting the revision graph. The number of revisions to return is also
         bounded by the **limit** query parameter.
 
         .. warning::
             To get the full BFS traversal of the revision graph when the
             total number of revisions is greater than 1000, it is up to
             the client to keep track of the multiple branches of history
             when there's merge revisions in the returned objects.
             In other words, identify all the continuation points that need
             to be followed to get the full history through recursion.
 
         :param string sha1_git: hexadecimal representation of the revision
             **sha1_git** identifier
         :query int limit: maximum number of revisions to return when performing
             BFS traversal on the revision graph (default to 10, can not exceed 1000)
 
         {common_headers}
 
         {return_revision_array}
 
         :statuscode 200: no error
         :statuscode 400: an invalid **sha1_git** value has been provided
         :statuscode 404: head revision can not be found in the archive
 
         **Example:**
 
         .. parsed-literal::
 
             :swh_web_api:`revision/e1a315fa3fa734e2a6154ed7b5b9ae0eb8987aad/log/`
     """
     limit = int(request.query_params.get("limit", "10"))
     limit = min(limit, 1000)
 
     error_msg = "Revision with sha1_git %s not found." % sha1_git
     revisions = api_lookup(
         archive.lookup_revision_log,
         sha1_git,
         limit,
         notfound_msg=error_msg,
         enrich_fn=utils.enrich_revision,
         request=request,
     )
 
     return {"results": revisions}
diff --git a/swh/web/tests/api/test_apidoc.py b/swh/web/tests/api/test_apidoc.py
index b206380c..ce950573 100644
--- a/swh/web/tests/api/test_apidoc.py
+++ b/swh/web/tests/api/test_apidoc.py
@@ -1,488 +1,487 @@
 # Copyright (C) 2015-2019  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import textwrap
 
 import pytest
 
 from rest_framework.response import Response
 
 from swh.storage.exc import StorageAPIError, StorageDBError
 from swh.web.api.apidoc import _parse_httpdomain_doc, api_doc
 from swh.web.api.apiurls import api_route
 from swh.web.common.exc import BadInputExc, ForbiddenExc, NotFoundExc
 from swh.web.common.utils import prettify_html, reverse
 from swh.web.tests.utils import check_api_get_responses, check_html_get_response
 
 _httpdomain_doc = """
 .. http:get:: /api/1/revision/(sha1_git)/
 
     Get information about a revision in the archive.
     Revisions are identified by **sha1** checksums, compatible with Git commit
     identifiers.
     See :func:`swh.model.git_objects.revision_git_object` in our data model
     module for details about how they are computed.
 
     :param string sha1_git: hexadecimal representation of the revision
         **sha1_git** identifier
 
     :reqheader Accept: the requested response content type,
         either ``application/json`` (default) or ``application/yaml``
     :resheader Content-Type: this depends on :http:header:`Accept` header
         of request
 
     :<json int n: sample input integer
     :<json string s: sample input string
     :<json array a: sample input array
 
     :>json object author: information about the author of the revision
     :>json object committer: information about the committer of the revision
-    :>json string committer_date: ISO representation of the commit date
-        (in UTC)
-    :>json string date: ISO representation of the revision date (in UTC)
+    :>json string committer_date: RFC3339 representation of the commit date
+    :>json string date: RFC3339 representation of the revision date
     :>json string directory: the unique identifier that revision points to
     :>json string directory_url: link to
         :http:get:`/api/1/directory/(sha1_git)/[(path)/]` to get information
         about the directory associated to the revision
     :>json string id: the revision unique identifier
     :>json boolean merge: whether or not the revision corresponds to a merge
         commit
     :>json string message: the message associated to the revision
     :>json array parents: the parents of the revision, i.e. the previous
         revisions that head directly to it, each entry of that array contains
         an unique parent revision identifier but also a link to
         :http:get:`/api/1/revision/(sha1_git)/` to get more information
         about it
     :>json string type: the type of the revision
 
     :statuscode 200: no error
     :statuscode 400: an invalid **sha1_git** value has been provided
     :statuscode 404: requested revision can not be found in the archive
 
     **Example:**
 
     .. parsed-literal::
 
         :swh_web_api:`revision/aafb16d69fd30ff58afdd69036a26047f3aebdc6/`
 """
 
 
 _exception_http_code = {
     BadInputExc: 400,
     ForbiddenExc: 403,
     NotFoundExc: 404,
     Exception: 500,
     StorageAPIError: 503,
     StorageDBError: 503,
 }
 
 
 def test_apidoc_nodoc_failure():
     with pytest.raises(Exception):
 
         @api_doc("/my/nodoc/url/")
         def apidoc_nodoc_tester(request, arga=0, argb=0):
             return Response(arga + argb)
 
 
 @api_route(r"/some/(?P<myarg>[0-9]+)/(?P<myotherarg>[0-9]+)/", "api-1-some-doc-route")
 @api_doc("/some/doc/route/")
 def apidoc_route(request, myarg, myotherarg, akw=0):
     """
     Sample doc
     """
     return {"result": int(myarg) + int(myotherarg) + akw}
 
 
 def test_apidoc_route_doc(client):
     url = reverse("api-1-some-doc-route-doc")
     check_html_get_response(
         client, url, status_code=200, template_used="api/apidoc.html"
     )
 
 
 def test_apidoc_route_fn(api_client):
     url = reverse("api-1-some-doc-route", url_args={"myarg": 1, "myotherarg": 1})
     check_api_get_responses(api_client, url, status_code=200)
 
 
 @api_route(r"/test/error/(?P<exc_name>.+)/", "api-1-test-error")
 @api_doc("/test/error/")
 def apidoc_test_error_route(request, exc_name):
     """
     Sample doc
     """
     for e in _exception_http_code.keys():
         if e.__name__ == exc_name:
             raise e("Error")
 
 
 def test_apidoc_error(api_client):
     for exc, code in _exception_http_code.items():
         url = reverse("api-1-test-error", url_args={"exc_name": exc.__name__})
         check_api_get_responses(api_client, url, status_code=code)
 
 
 @api_route(
     r"/some/full/(?P<myarg>[0-9]+)/(?P<myotherarg>[0-9]+)/",
     "api-1-some-complete-doc-route",
 )
 @api_doc("/some/complete/doc/route/")
 def apidoc_full_stack(request, myarg, myotherarg, akw=0):
     """
     Sample doc
     """
     return {"result": int(myarg) + int(myotherarg) + akw}
 
 
 def test_apidoc_full_stack_doc(client):
     url = reverse("api-1-some-complete-doc-route-doc")
     check_html_get_response(
         client, url, status_code=200, template_used="api/apidoc.html"
     )
 
 
 def test_apidoc_full_stack_fn(api_client):
     url = reverse(
         "api-1-some-complete-doc-route", url_args={"myarg": 1, "myotherarg": 1}
     )
     check_api_get_responses(api_client, url, status_code=200)
 
 
 @api_route(r"/test/post/only/", "api-1-test-post-only", methods=["POST"])
 @api_doc("/test/post/only/")
 def apidoc_test_post_only(request, exc_name):
     """
     Sample doc
     """
     return {"result": "some data"}
 
 
 def test_apidoc_post_only(client):
     # a dedicated view accepting GET requests should have
     # been created to display the HTML documentation
     url = reverse("api-1-test-post-only-doc")
     check_html_get_response(
         client, url, status_code=200, template_used="api/apidoc.html"
     )
 
 
 def test_api_doc_parse_httpdomain():
     doc_data = {
         "description": "",
         "urls": [],
         "args": [],
         "params": [],
         "resheaders": [],
         "reqheaders": [],
         "input_type": "",
         "inputs": [],
         "return_type": "",
         "returns": [],
         "status_codes": [],
         "examples": [],
     }
 
     _parse_httpdomain_doc(_httpdomain_doc, doc_data)
 
     expected_urls = [
         {
             "rule": "/api/1/revision/ **\\(sha1_git\\)** /",
             "methods": ["GET", "HEAD", "OPTIONS"],
         }
     ]
 
     assert "urls" in doc_data
     assert doc_data["urls"] == expected_urls
 
     expected_description = (
         "Get information about a revision in the archive. "
         "Revisions are identified by **sha1** checksums, "
         "compatible with Git commit identifiers. See "
         "**swh.model.git_objects.revision_git_object** in "
         "our data model module for details about how they "
         "are computed."
     )
 
     assert "description" in doc_data
     assert doc_data["description"] == expected_description
 
     expected_args = [
         {
             "name": "sha1_git",
             "type": "string",
             "doc": (
                 "hexadecimal representation of the revision " "**sha1_git** identifier"
             ),
         }
     ]
 
     assert "args" in doc_data
     assert doc_data["args"] == expected_args
 
     expected_params = []
     assert "params" in doc_data
     assert doc_data["params"] == expected_params
 
     expected_reqheaders = [
         {
             "doc": (
                 "the requested response content type, either "
                 "``application/json`` (default) or ``application/yaml``"
             ),
             "name": "Accept",
         }
     ]
 
     assert "reqheaders" in doc_data
     assert doc_data["reqheaders"] == expected_reqheaders
 
     expected_resheaders = [
         {"doc": "this depends on **Accept** header of request", "name": "Content-Type"}
     ]
 
     assert "resheaders" in doc_data
     assert doc_data["resheaders"] == expected_resheaders
 
     expected_statuscodes = [
         {"code": "200", "doc": "no error"},
         {"code": "400", "doc": "an invalid **sha1_git** value has been provided"},
         {"code": "404", "doc": "requested revision can not be found in the archive"},
     ]
 
     assert "status_codes" in doc_data
     assert doc_data["status_codes"] == expected_statuscodes
 
     expected_input_type = "object"
 
     assert "input_type" in doc_data
     assert doc_data["input_type"] == expected_input_type
 
     expected_inputs = [
         {"name": "n", "type": "int", "doc": "sample input integer"},
         {"name": "s", "type": "string", "doc": "sample input string"},
         {"name": "a", "type": "array", "doc": "sample input array"},
     ]
 
     assert "inputs" in doc_data
     assert doc_data["inputs"] == expected_inputs
 
     expected_return_type = "object"
 
     assert "return_type" in doc_data
     assert doc_data["return_type"] == expected_return_type
 
     expected_returns = [
         {
             "name": "author",
             "type": "object",
             "doc": "information about the author of the revision",
         },
         {
             "name": "committer",
             "type": "object",
             "doc": "information about the committer of the revision",
         },
         {
             "name": "committer_date",
             "type": "string",
-            "doc": "ISO representation of the commit date (in UTC)",
+            "doc": "RFC3339 representation of the commit date",
         },
         {
             "name": "date",
             "type": "string",
-            "doc": "ISO representation of the revision date (in UTC)",
+            "doc": "RFC3339 representation of the revision date",
         },
         {
             "name": "directory",
             "type": "string",
             "doc": "the unique identifier that revision points to",
         },
         {
             "name": "directory_url",
             "type": "string",
             "doc": (
                 "link to `/api/1/directory/ </api/1/directory/doc/>`_ "
                 "to get information about the directory associated to "
                 "the revision"
             ),
         },
         {"name": "id", "type": "string", "doc": "the revision unique identifier"},
         {
             "name": "merge",
             "type": "boolean",
             "doc": "whether or not the revision corresponds to a merge commit",
         },
         {
             "name": "message",
             "type": "string",
             "doc": "the message associated to the revision",
         },
         {
             "name": "parents",
             "type": "array",
             "doc": (
                 "the parents of the revision, i.e. the previous revisions "
                 "that head directly to it, each entry of that array "
                 "contains an unique parent revision identifier but also a "
                 "link to `/api/1/revision/ </api/1/revision/doc/>`_ "
                 "to get more information about it"
             ),
         },
         {"name": "type", "type": "string", "doc": "the type of the revision"},
     ]
 
     assert "returns" in doc_data
     assert doc_data["returns"] == expected_returns
 
     expected_examples = ["/api/1/revision/aafb16d69fd30ff58afdd69036a26047f3aebdc6/"]
 
     assert "examples" in doc_data
     assert doc_data["examples"] == expected_examples
 
 
 @api_route(r"/post/endpoint/", "api-1-post-endpoint", methods=["POST"])
 @api_doc("/post/endpoint/")
 def apidoc_test_post_endpoint(request):
     """
     .. http:post:: /api/1/post/endpoint/
 
         Endpoint documentation
 
         :<jsonarr string -: Input array of SWHIDs
 
         :>json object <swhid>: an object whose keys are input SWHIDs
             and values objects with the following keys:
 
                 * **known (bool)**: whether the object was found
 
     """
     pass
 
 
 def test_apidoc_input_output_doc(client):
     url = reverse("api-1-post-endpoint-doc")
     rv = check_html_get_response(
         client, url, status_code=200, template_used="api/apidoc.html"
     )
 
     input_html_doc = textwrap.indent(
         (
             '<dl class="row">\n'
             ' <dt class="col col-md-2 text-right">\n'
             "  array\n"
             " </dt>\n"
             ' <dd class="col col-md-9">\n'
             "  <p>\n"
             "   Input array of SWHIDs\n"
             "  </p>\n"
             " </dd>\n"
             "</dl>\n"
         ),
         " " * 7,
     )
 
     output_html_doc = textwrap.indent(
         (
             '<dl class="row">\n'
             ' <dt class="col col-md-2 text-right">\n'
             "  object\n"
             " </dt>\n"
             ' <dd class="col col-md-9">\n'
             "  <p>\n"
             "   an object containing the following keys:\n"
             "  </p>\n"
             '  <div class="swh-rst">\n'
             "   <blockquote>\n"
             "    <ul>\n"
             "     <li>\n"
             "      <p>\n"
             "       <strong>\n"
             "        &lt;swhid&gt; (object)\n"
             "       </strong>\n"
             "       :           an object whose keys are input SWHIDs"
             " and values objects with the following keys:\n"
             "      </p>\n"
             "      <blockquote>\n"
             '       <ul class="simple">\n'
             "        <li>\n"
             "         <p>\n"
             "          <strong>\n"
             "           known (bool)\n"
             "          </strong>\n"
             "          : whether the object was found\n"
             "         </p>\n"
             "        </li>\n"
             "       </ul>\n"
             "      </blockquote>\n"
             "     </li>\n"
             "    </ul>\n"
             "   </blockquote>\n"
             "  </div>\n"
             " </dd>\n"
             "</dl>\n"
         ),
         " " * 7,
     )
 
     html = prettify_html(rv.content)
 
     assert input_html_doc in html
     assert output_html_doc in html
 
 
 @api_route(r"/endpoint/links/in/doc/", "api-1-endpoint-links-in-doc")
 @api_doc("/endpoint/links/in/doc/")
 def apidoc_test_endpoint_with_links_in_doc(request):
     """
     .. http:get:: /api/1/post/endpoint/
 
         Endpoint documentation with links to
         :http:get:`/api/1/content/[(hash_type):](hash)/`,
         :http:get:`/api/1/directory/(sha1_git)/[(path)/]`
         and `archive <https://archive.softwareheritage.org>`_.
     """
     pass
 
 
 def test_apidoc_with_links(client):
     url = reverse("api-1-endpoint-links-in-doc")
     rv = check_html_get_response(
         client, url, status_code=200, template_used="api/apidoc.html"
     )
 
     html = prettify_html(rv.content)
 
     first_link = textwrap.indent(
         (
             '<a class="reference external" href="/api/1/content/doc/">\n'
             " /api/1/content/\n"
             "</a>"
         ),
         " " * 9,
     )
 
     second_link = textwrap.indent(
         (
             '<a class="reference external" href="/api/1/directory/doc/">\n'
             " /api/1/directory/\n"
             "</a>"
         ),
         " " * 9,
     )
 
     third_link = textwrap.indent(
         (
             '<a class="reference external" '
             'href="https://archive.softwareheritage.org">\n'
             " archive\n"
             "</a>"
         ),
         " " * 9,
     )
 
     assert first_link in html
     assert second_link in html
     assert third_link in html