diff --git a/swh/web/api/apiresponse.py b/swh/web/api/apiresponse.py
index e1c212ae5..e6e18b1fc 100644
--- a/swh/web/api/apiresponse.py
+++ b/swh/web/api/apiresponse.py
@@ -1,180 +1,180 @@
 # Copyright (C) 2017-2018  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 json
 
 from rest_framework.response import Response
 
 from swh.storage.exc import StorageDBError, StorageAPIError
 
 from swh.web.common.exc import NotFoundExc, ForbiddenExc
 from swh.web.common.utils import shorten_path, gen_path_info
 from swh.web.api import utils
 
 
 def compute_link_header(rv, options):
     """Add Link header in returned value results.
 
     Args:
         rv (dict): dictionary with keys:
 
             - headers: potential headers with 'link-next' and 'link-prev'
               keys
             - results: containing the result to return
 
         options (dict): the initial dict to update with result if any
 
     Returns:
         dict: dictionary with optional keys 'link-next' and 'link-prev'
 
     """
     link_headers = []
 
     if 'headers' not in rv:
         return {}
 
     rv_headers = rv['headers']
 
     if 'link-next' in rv_headers:
         link_headers.append('<%s>; rel="next"' % (
             rv_headers['link-next']))
     if 'link-prev' in rv_headers:
         link_headers.append('<%s>; rel="previous"' % (
             rv_headers['link-prev']))
 
     if link_headers:
         link_header_str = ','.join(link_headers)
         headers = options.get('headers', {})
         headers.update({
             'Link': link_header_str
         })
         return headers
 
     return {}
 
 
 def filter_by_fields(request, data):
     """Extract a request parameter 'fields' if it exists to permit the filtering on
     he data dict's keys.
 
     If such field is not provided, returns the data as is.
 
     """
     fields = request.query_params.get('fields')
     if fields:
         fields = set(fields.split(','))
         data = utils.filter_field_keys(data, fields)
 
     return data
 
 
 def transform(rv):
     """Transform an eventual returned value with multiple layer of
     information with only what's necessary.
 
     If the returned value rv contains the 'results' key, this is the
     associated value which is returned.
 
     Otherwise, return the initial dict without the potential 'headers'
     key.
 
     """
     if 'results' in rv:
         return rv['results']
 
     if 'headers' in rv:
         rv.pop('headers')
 
     return rv
 
 
 def make_api_response(request, data, doc_data={}, options={}):
     """Generates an API response based on the requested mimetype.
 
     Args:
         request: a DRF Request object
         data: raw data to return in the API response
         doc_data: documentation data for HTML response
         options: optionnal data that can be used to generate the response
 
     Returns:
         a DRF Response a object
 
     """
     if data:
         options['headers'] = compute_link_header(data, options)
         data = transform(data)
         data = filter_by_fields(request, data)
     doc_env = doc_data
     headers = {}
     if 'headers' in options:
         doc_env['headers_data'] = options['headers']
         headers = options['headers']
 
     # get request status code
     doc_env['status_code'] = options.get('status', 200)
 
     response_args = {'status': doc_env['status_code'],
                      'headers': headers,
                      'content_type': request.accepted_media_type}
 
     # when requesting HTML, typically when browsing the API through its
     # documented views, we need to enrich the input data with documentation
     # related ones and inform DRF that we request HTML template rendering
     if request.accepted_media_type == 'text/html':
 
         if data:
             data = json.dumps(data, sort_keys=True,
                               indent=4,
                               separators=(',', ': '))
         doc_env['response_data'] = data
         doc_env['request'] = {
             'path': request.path,
             'method': request.method,
-            'absolute_uri': request.build_absolute_uri()
+            'absolute_uri': request.build_absolute_uri(),
         }
         doc_env['heading'] = shorten_path(str(request.path))
 
         if 'route' in doc_env:
             doc_env['endpoint_path'] = gen_path_info(doc_env['route'])
 
         response_args['data'] = doc_env
         response_args['template_name'] = 'apidoc.html'
 
     # otherwise simply return the raw data and let DRF picks
     # the correct renderer (JSON or YAML)
     else:
         response_args['data'] = data
 
     return Response(**response_args)
 
 
 def error_response(request, error, doc_data):
     """Private function to create a custom error response.
 
     Args:
         request: a DRF Request object
         error: the exception that caused the error
         doc_data: documentation data for HTML response
 
     """
     error_code = 400
     if isinstance(error, NotFoundExc):
         error_code = 404
     elif isinstance(error, ForbiddenExc):
         error_code = 403
     elif isinstance(error, StorageDBError):
         error_code = 503
     elif isinstance(error, StorageAPIError):
         error_code = 503
 
     error_opts = {'status': error_code}
     error_data = {
         'exception': error.__class__.__name__,
         'reason': str(error),
     }
 
     return make_api_response(request, error_data, doc_data,
                              options=error_opts)
diff --git a/swh/web/common/utils.py b/swh/web/common/utils.py
index ad6b29d83..bdc372280 100644
--- a/swh/web/common/utils.py
+++ b/swh/web/common/utils.py
@@ -1,374 +1,374 @@
 # Copyright (C) 2017-2018  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 docutils.parsers.rst
 import docutils.utils
 import re
 
 from datetime import datetime, timezone
 from dateutil import parser as date_parser
 from dateutil import tz
 
 from django.core.cache import cache
 from django.core import urlresolvers
 from django.http import QueryDict
 
 from swh.model.exceptions import ValidationError
 from swh.model.identifiers import (
     persistent_identifier, parse_persistent_identifier,
     CONTENT, DIRECTORY, RELEASE, REVISION, SNAPSHOT
 )
 from swh.web.common import service
 from swh.web.common.exc import BadInputExc
 
 
 def reverse(viewname, args=None, kwargs=None, query_params=None,
             current_app=None, urlconf=None):
     """An override of django reverse function supporting query parameters.
 
     Args:
         viewname: the name of the django view from which to compute a url
         args: list of url arguments ordered according to their position it
         kwargs: dictionary of url arguments indexed by their names
         query_params: dictionary of query parameters to append to the
             reversed url
         current_app: the name of the django app tighted to the view
         urlconf: url configuration module
 
     Returns:
         The url of the requested view with processed arguments and
         query parameters
     """
 
     if kwargs:
         kwargs = {k: v for k, v in kwargs.items() if v is not None}
 
     url = urlresolvers.reverse(
             viewname, urlconf=urlconf, args=args,
             kwargs=kwargs, current_app=current_app)
 
     if query_params:
         query_params = {k: v for k, v in query_params.items() if v is not None}
 
     if query_params and len(query_params) > 0:
         query_dict = QueryDict('', mutable=True)
         for k in sorted(query_params.keys()):
             query_dict[k] = query_params[k]
-        url += ('?' + query_dict.urlencode(safe='/'))
+        url += ('?' + query_dict.urlencode(safe='/;:'))
 
     return url
 
 
 def fmap(f, data):
     """Map f to data at each level.
 
     This must keep the origin data structure type:
     - map -> map
     - dict -> dict
     - list -> list
     - None -> None
 
     Args:
         f: function that expects one argument.
         data: data to traverse to apply the f function.
               list, map, dict or bare value.
 
     Returns:
         The same data-structure with modified values by the f function.
 
     """
     if data is None:
         return data
     if isinstance(data, map):
         return map(lambda y: fmap(f, y), (x for x in data))
     if isinstance(data, list):
         return [fmap(f, x) for x in data]
     if isinstance(data, dict):
         return {k: fmap(f, v) for (k, v) in data.items()}
     return f(data)
 
 
 def datetime_to_utc(date):
     """Returns datetime in UTC without timezone info
 
     Args:
         date (datetime.datetime): input datetime with timezone info
 
     Returns:
         datetime.datime: datetime in UTC without timezone info
     """
     if date.tzinfo:
         return date.astimezone(tz.gettz('UTC')).replace(tzinfo=timezone.utc)
     else:
         return date
 
 
 def parse_timestamp(timestamp):
     """Given a time or timestamp (as string), parse the result as UTC datetime.
 
     Returns:
         a timezone-aware datetime representing the parsed value.
         None if the parsing fails.
 
     Samples:
         - 2016-01-12
         - 2016-01-12T09:19:12+0100
         - Today is January 1, 2047 at 8:21:00AM
         - 1452591542
 
     """
     if not timestamp:
         return None
 
     try:
         date = date_parser.parse(timestamp, ignoretz=False, fuzzy=True)
         return datetime_to_utc(date)
     except Exception:
         try:
             return datetime.utcfromtimestamp(float(timestamp)).replace(
                 tzinfo=timezone.utc)
         except (ValueError, OverflowError) as e:
             raise BadInputExc(e)
 
 
 def shorten_path(path):
     """Shorten the given path: for each hash present, only return the first
     8 characters followed by an ellipsis"""
 
     sha256_re = r'([0-9a-f]{8})[0-9a-z]{56}'
     sha1_re = r'([0-9a-f]{8})[0-9a-f]{32}'
 
     ret = re.sub(sha256_re, r'\1...', path)
     return re.sub(sha1_re, r'\1...', ret)
 
 
 def format_utc_iso_date(iso_date, fmt='%d %B %Y, %H:%M UTC'):
     """Turns a string reprensation of an ISO 8601 date string
     to UTC and format it into a more human readable one.
 
     For instance, from the following input
     string: '2017-05-04T13:27:13+02:00' the following one
     is returned: '04 May 2017, 11:27 UTC'.
     Custom format string may also be provided
     as parameter
 
     Args:
         iso_date (str): a string representation of an ISO 8601 date
         fmt (str): optional date formatting string
 
     Returns:
         A formatted string representation of the input iso date
     """
     if not iso_date:
         return iso_date
     date = parse_timestamp(iso_date)
     return date.strftime(fmt)
 
 
 def gen_path_info(path):
     """Function to generate path data navigation for use
     with a breadcrumb in the swh web ui.
 
     For instance, from a path /folder1/folder2/folder3,
     it returns the following list::
 
         [{'name': 'folder1', 'path': 'folder1'},
          {'name': 'folder2', 'path': 'folder1/folder2'},
          {'name': 'folder3', 'path': 'folder1/folder2/folder3'}]
 
     Args:
         path: a filesystem path
 
     Returns:
         A list of path data for navigation as illustrated above.
 
     """
     path_info = []
     if path:
         sub_paths = path.strip('/').split('/')
         path_from_root = ''
         for p in sub_paths:
             path_from_root += '/' + p
             path_info.append({'name': p,
                               'path': path_from_root.strip('/')})
     return path_info
 
 
 def get_origin_visits(origin_info):
     """Function that returns the list of visits for a swh origin.
     That list is put in cache in order to speedup the navigation
     in the swh web browse ui.
 
     Args:
         origin_id (int): the id of the swh origin to fetch visits from
 
     Returns:
         A list of dict describing the origin visits::
 
             [{'date': <UTC visit date in ISO format>,
               'origin': <origin id>,
               'status': <'full' | 'partial'>,
               'visit': <visit id>
              },
              ...
             ]
 
     Raises:
         NotFoundExc if the origin is not found
     """
     cache_entry_id = 'origin_%s_visits' % origin_info['id']
     cache_entry = cache.get(cache_entry_id)
 
     if cache_entry:
         return cache_entry
 
     origin_visits = []
 
     per_page = service.MAX_LIMIT
     last_visit = None
     while 1:
         visits = list(service.lookup_origin_visits(origin_info['id'],
                                                    last_visit=last_visit,
                                                    per_page=per_page))
         origin_visits += visits
         if len(visits) < per_page:
             break
         else:
             if not last_visit:
                 last_visit = per_page
             else:
                 last_visit += per_page
 
     def _visit_sort_key(visit):
         ts = parse_timestamp(visit['date']).timestamp()
         return ts + (float(visit['visit']) / 10e3)
 
     for v in origin_visits:
         if 'metadata' in v:
             del v['metadata']
     origin_visits = [dict(t) for t in set([tuple(d.items())
                                            for d in origin_visits])]
     origin_visits = sorted(origin_visits, key=lambda v: _visit_sort_key(v))
 
     cache.set(cache_entry_id, origin_visits)
 
     return origin_visits
 
 
 def get_swh_persistent_id(object_type, object_id, scheme_version=1):
     """
     Returns the persistent identifier for a swh object based on:
 
         * the object type
         * the object id
         * the swh identifiers scheme version
 
     Args:
         object_type (str): the swh object type
             (content/directory/release/revision/snapshot)
         object_id (str): the swh object id (hexadecimal representation
             of its hash value)
         scheme_version (int): the scheme version of the swh
             persistent identifiers
 
     Returns:
         str: the swh object persistent identifier
 
     Raises:
         BadInputExc if the provided parameters do not enable to
             generate a valid identifier
     """
     try:
         swh_id = persistent_identifier(object_type, object_id, scheme_version)
     except ValidationError as e:
         raise BadInputExc('Invalid object (%s) for swh persistent id. %s' %
                           (object_id, e))
     else:
         return swh_id
 
 
 def resolve_swh_persistent_id(swh_id, query_params=None):
     """
     Try to resolve a SWH persistent id into an url for
     browsing the pointed object.
 
     Args:
         swh_id (str): a SWH persistent identifier
         query_params (django.http.QueryDict): optional dict filled with
             query parameters to append to the browse url
 
     Returns:
         dict: a dict with the following keys:
 
             * **swh_id_parsed (swh.model.identifiers.PersistentId)**: the parsed identifier
             * **browse_url (str)**: the url for browsing the pointed object
 
     Raises:
         BadInputExc: if the provided identifier can not be parsed
     """ # noqa
     try:
         swh_id_parsed = parse_persistent_identifier(swh_id)
         object_type = swh_id_parsed.object_type
         object_id = swh_id_parsed.object_id
         browse_url = None
         if not query_params:
             query_params = QueryDict('', mutable=True)
         if 'origin' in swh_id_parsed.metadata:
             query_params['origin'] = swh_id_parsed.metadata['origin']
         if object_type == CONTENT:
             query_string = 'sha1_git:' + object_id
             fragment = ''
             if 'lines' in swh_id_parsed.metadata:
                 lines = swh_id_parsed.metadata['lines'].split('-')
                 fragment += '#L' + lines[0]
                 if len(lines) > 1:
                     fragment += '-L' + lines[1]
             browse_url = reverse('browse-content',
                                  kwargs={'query_string': query_string},
                                  query_params=query_params) + fragment
         elif object_type == DIRECTORY:
             browse_url = reverse('browse-directory',
                                  kwargs={'sha1_git': object_id},
                                  query_params=query_params)
         elif object_type == RELEASE:
             browse_url = reverse('browse-release',
                                  kwargs={'sha1_git': object_id},
                                  query_params=query_params)
         elif object_type == REVISION:
             browse_url = reverse('browse-revision',
                                  kwargs={'sha1_git': object_id},
                                  query_params=query_params)
         elif object_type == SNAPSHOT:
             browse_url = reverse('browse-snapshot',
                                  kwargs={'snapshot_id': object_id},
                                  query_params=query_params)
     except ValidationError as ve:
         raise BadInputExc('Error when parsing identifier. %s' %
                           ' '.join(ve.messages))
     else:
         return {'swh_id_parsed': swh_id_parsed,
                 'browse_url': browse_url}
 
 
 def parse_rst(text, report_level=2):
     """
     Parse a reStructuredText string with docutils.
 
     Args:
         text (str): string with reStructuredText markups in it
         report_level (int): level of docutils report messages to print
             (1 info 2 warning 3 error 4 severe 5 none)
 
     Returns:
         docutils.nodes.document: a parsed docutils document
     """
     parser = docutils.parsers.rst.Parser()
     components = (docutils.parsers.rst.Parser,)
     settings = docutils.frontend.OptionParser(
         components=components).get_default_values()
     settings.report_level = report_level
     document = docutils.utils.new_document('rst-doc', settings=settings)
     parser.parse(text, document)
     return document
diff --git a/swh/web/templates/apidoc.html b/swh/web/templates/apidoc.html
index f79b71de1..598319502 100644
--- a/swh/web/templates/apidoc.html
+++ b/swh/web/templates/apidoc.html
@@ -1,182 +1,182 @@
 {% extends "layout.html" %}
 
 {% comment %}
 Copyright (C) 2015-2018  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
 {% endcomment %}
 
 {% load swh_templatetags %}
 {% load render_bundle from webpack_loader %}
 
 {% block title %}{{ heading }} &ndash; Software Heritage API {% endblock %}
 
 {% block navbar-content %}
 <nav class="bread-crumbs">
   <ul>
     <li><a href="/api/"><h4>Web API</h4></a></li>
     <li class="bc-no-root"><i class="fa fa-caret-right fa-fw" aria-hidden="true"></i></li>
     <li class="bc-no-root"><a href="/api/1/">endpoints</a></li>
     {% for endpoint in endpoint_path %}
       <li class="bc-no-root"><i class="fa fa-caret-right fa-fw" aria-hidden="true"></i></li>
       {% if endpoint.name != 'stat' %}
         <li class="bc-no-root"><a href="{{ '/api/1/'|add:endpoint.path }}">{{ endpoint.name }}</a></li>
       {% else %}
         <li class="bc-no-root"><span>{{ endpoint.name }}</span></li>
       {% endif %}
     {% endfor %}
   </ul>
 </nav>
 {% endblock %}
 
 {% block content %}
 
 {% if description %}
   <div>
     <h4> Description </h4>
     {{ description | safe_docstring_display | safe }}
   </div>
 {% endif %}
 {% if response_data  %}
   <div>
     <h4>Request</h4>
-    <pre><strong>{{ request.method }}</strong> {{ request.absolute_uri }}</pre>
+    <pre><strong>{{ request.method }}</strong> {{ request.path }}</pre>
     <hr/>
     <h4>Response</h4>
     {% if status_code != 200 %}
       <h5>Status Code</h5>
       <pre>{{ status_code }}</pre>
     {% endif %}
     {% if headers_data %}
       <h5>Headers</h5>
       {% for header_name, header_value in headers_data.items %}
         <pre><strong>{{ header_name }}</strong> {{ header_value | urlize_header_links | safe }}</pre>
       {% endfor %}
     {% endif %}
     <h5>Body</h5>
     <pre><code class="json">{{ response_data | urlize_links_and_mails | safe }}</code></pre>
   </div>
 {% endif %}
 <hr/>
 {% if urls and urls|length > 0 %}
   <div>
     <table class="m-x-auto table">
       <thead>
         <tr>
           <th>URL</th>
           <th>Allowed Methods</th>
         </tr>
       </thead>
       <tbody>
         {% for url in urls %}
           <tr>
             <td>{{ url.rule | safe_docstring_display | safe }}</td>
             <td>{{ url.methods | dictsort:0 | join:', ' }}</td>
           </tr>
         {% endfor %}
       </tbody>
     </table>
   </div>
   <hr/>
 {% endif %}
 {% if args and args|length > 0 %}
   <div>
     <h4> Arguments </h4>
     {% for arg in args %}
       <dl class="row">
         <dt class="col col-md-2 text-right"> {{ arg.name }} ({{ arg.type }}) </dt>
         <dd class="col col-md-9"> {{ arg.doc | safe_docstring_display | safe }} </dd>
       </dl>
     {% endfor %}
   </div>
   <hr/>
 {% endif %}
 {% if params and params|length > 0 %}
   <div>
     <h4> Query parameters </h4>
     {% for param in params %}
       <dl class="row">
         <dt class="col col-md-2 text-right"> {{ param.name }} ({{ param.type }}) </dt>
         <dd class="col col-md-9"> {{ param.doc | safe_docstring_display | safe }} </dd>
       </dl>
     {% endfor %}
   </div>
   <hr/>
 {% endif %}
 {% if reqheaders and reqheaders|length > 0 %}
   <div>
     <h4> Request headers </h4>
     {% for header in reqheaders %}
       <dl class="row">
         <dt class="col col-md-2 text-right"> {{ header.name }} </dt>
         <dd class="col col-md-9"> {{ header.doc | safe_docstring_display | safe }} </dd>
       </dl>
     {% endfor %}
   </div>
 <hr/>
 {% endif %}
 {% if resheaders and resheaders|length > 0 %}
   <div>
     <h4> Response headers </h4>
     {% for header in resheaders %}
       <dl class="row">
         <dt class="col col-md-2 text-right"> {{ header.name }} </dt>
         <dd class="col col-md-9"> {{ header.doc | safe_docstring_display | safe }} </dd>
       </dl>
     {% endfor %}
   </div>
 <hr/>
 {% endif %}
 {% if return_type %}
   <div>
     <h4> Returns </h4>
     <dl class="row">
       <dt class="col col-md-2 text-right"> {{ return_type }} </dt>
       <dd class="col col-md-9">
         <p>
           {% if return_type == 'array' %}
             an array of objects containing the following keys:
           {% elif return_type == 'octet stream' %}
             the raw data as an octet stream
           {% else %}
             an object containing the following keys:
           {% endif %}
           {{ returns_list | safe_docstring_display | safe }}
         </p>
       </dd>
     </dl>
   </div>
   <hr/>
 {% endif %}
 {% if status_codes and status_codes|length > 0 %}
   <div>
     <h4> HTTP status codes </h4>
     {% for status in status_codes %}
       <dl class="row">
         <dt class="col col-md-2 text-right"> {{ status.code }} </dt>
         <dd class="col col-md-9"> {{ status.doc | safe_docstring_display | safe }} </dd>
       </dl>
     {% endfor %}
   </div>
   <hr/>
 {% endif %}
 {% if examples and examples|length > 0 %}
   <div>
     <h4> Examples </h4>
     {% for example in examples %}
       <dl class="row">
         <dt class="col col-md-2"></dt>
         <dd class="col col-md-9">
           <a href="{{ example }}">{{ example }}</a>
         </dd>
       </dl>
     {% endfor %}
   </div>
 {% endif %}
 
 <script>
   swh.webapp.initPage('api');
   swh.webapp.highlightCode(false);
 </script>
 {% endblock %}