diff --git a/swh/web/assets/src/bundles/browse/swhid-utils.js b/swh/web/assets/src/bundles/browse/swhid-utils.js
index 72ca002d..a5661661 100644
--- a/swh/web/assets/src/bundles/browse/swhid-utils.js
+++ b/swh/web/assets/src/bundles/browse/swhid-utils.js
@@ -1,120 +1,122 @@
 /**
  * Copyright (C) 2018-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 ClipboardJS from 'clipboard';
 import 'thirdparty/jquery.tabSlideOut/jquery.tabSlideOut';
 import 'thirdparty/jquery.tabSlideOut/jquery.tabSlideOut.css';
 
 import {BREAKPOINT_SM} from 'utils/constants';
 
 export function swhIdObjectTypeToggled(event) {
   event.preventDefault();
   $(event.target).tab('show');
 }
 
 export function swhIdContextOptionToggled(event) {
   event.stopPropagation();
   let swhIdElt = $(event.target).closest('.swhid-ui').find('.swhid');
   let swhIdWithContext = $(event.target).data('swhid-with-context');
+  let swhIdWithContextUrl = $(event.target).data('swhid-with-context-url');
   let currentSwhId = swhIdElt.text();
   if ($(event.target).prop('checked')) {
     currentSwhId = swhIdWithContext;
+    swhIdElt.attr('href', swhIdWithContextUrl);
   } else {
     const pos = currentSwhId.indexOf(';');
     if (pos !== -1) {
       currentSwhId = currentSwhId.slice(0, pos);
     }
+    swhIdElt.attr('href', '/' + currentSwhId + '/');
   }
   swhIdElt.text(currentSwhId);
-  swhIdElt.attr('href', '/' + currentSwhId + '/');
 
   addLinesInfo();
 }
 
 function addLinesInfo() {
   let swhIdElt = $('#swhid-tab-content').find('.swhid');
   let currentSwhId = swhIdElt.text();
   let lines = [];
   let linesPart = ';lines=';
   let linesRegexp = new RegExp(/L(\d+)/g);
   let line = linesRegexp.exec(window.location.hash);
   while (line) {
     lines.push(parseInt(line[1]));
     line = linesRegexp.exec(window.location.hash);
   }
   if (lines.length > 0) {
     linesPart += lines[0];
   }
   if (lines.length > 1) {
     linesPart += '-' + lines[1];
   }
 
   if ($('#swhid-context-option-content').prop('checked')) {
     currentSwhId = currentSwhId.replace(/;lines=\d+-*\d*/g, '');
     if (lines.length > 0) {
       currentSwhId += linesPart;
     }
 
     swhIdElt.text(currentSwhId);
     swhIdElt.attr('href', '/' + currentSwhId + '/');
   }
 }
 
 $(document).ready(() => {
   new ClipboardJS('.btn-swhid-copy', {
     text: trigger => {
       let swhId = $(trigger).closest('.swhid-ui').find('.swhid').text();
       return swhId;
     }
   });
 
   new ClipboardJS('.btn-swhid-url-copy', {
     text: trigger => {
-      let swhId = $(trigger).closest('.swhid-ui').find('.swhid').text();
-      return window.location.origin + '/' + swhId + '/';
+      let swhIdUrl = $(trigger).closest('.swhid-ui').find('.swhid').attr('href');
+      return window.location.origin + swhIdUrl;
     }
   });
 
   if (window.innerWidth * 0.7 > 1000) {
     $('#swh-identifiers').css('width', '1000px');
   }
 
   let tabSlideOptions = {
     tabLocation: 'right',
     clickScreenToCloseFilters: ['.ui-slideouttab-panel', '.modal'],
     offset: function() {
       const width = $(window).width();
       if (width < BREAKPOINT_SM) {
         return '250px';
       } else {
         return '200px';
       }
     }
   };
   // ensure tab scrolling on small screens
   if (window.innerHeight < 600 || window.innerWidth < 500) {
     tabSlideOptions['otherOffset'] = '20px';
   }
 
   // initiate the sliding identifiers tab
   $('#swh-identifiers').tabSlideOut(tabSlideOptions);
 
   // set the tab visible once the close animation is terminated
   $('#swh-identifiers').css('display', 'block');
   $('.swhid-context-option').trigger('click');
 
   // highlighted code lines changed
   $(window).on('hashchange', () => {
     addLinesInfo();
   });
 
   // highlighted code lines removed
   $('body').click(() => {
     addLinesInfo();
   });
 
 });
diff --git a/swh/web/assets/src/bundles/webapp/badges.js b/swh/web/assets/src/bundles/webapp/badges.js
index 3e14a8bd..efc1c41d 100644
--- a/swh/web/assets/src/bundles/webapp/badges.js
+++ b/swh/web/assets/src/bundles/webapp/badges.js
@@ -1,49 +1,51 @@
 /**
  * Copyright (C) 2019-2020  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
  */
 
 export function showBadgeInfoModal(objectType, objectSWHID) {
   let badgeImageUrl;
   let badgeLinkUrl;
   if (objectType === 'origin') {
     badgeImageUrl = Urls.swh_badge(objectType, objectSWHID);
     badgeLinkUrl = `${Urls.browse_origin()}?origin_url=${objectSWHID}`;
   } else {
     const pos = objectSWHID.indexOf(';');
     if (pos !== -1) {
-      badgeImageUrl = Urls.swh_badge_swhid(objectSWHID.slice(0, pos));
+      const objectSWHIDNoContext = objectSWHID.slice(0, pos);
+      badgeImageUrl = Urls.swh_badge_swhid(objectSWHIDNoContext);
+      $('.swhid').each((i, swhid) => {
+        if (swhid.id === objectSWHIDNoContext) {
+          badgeLinkUrl = swhid.pathname;
+        }
+      });
     } else {
       badgeImageUrl = Urls.swh_badge_swhid(objectSWHID);
+      badgeLinkUrl = Urls.browse_swhid(objectSWHID);
     }
-    badgeLinkUrl = Urls.browse_swhid(objectSWHID);
   }
-  let urlPrefix = `${window.location.protocol}//${window.location.hostname}`;
-  if (window.location.port) {
-    urlPrefix += `:${window.location.port}`;
-  }
-  const absoluteBadgeImageUrl = `${urlPrefix}${badgeImageUrl}`;
-  const absoluteBadgeLinkUrl = `${urlPrefix}${badgeLinkUrl}`;
+  const absoluteBadgeImageUrl = `${window.location.origin}${badgeImageUrl}`;
+  const absoluteBadgeLinkUrl = `${window.location.origin}${badgeLinkUrl}`;
   const html = `
   <a href="${absoluteBadgeLinkUrl}">
     <img class="swh-badge" src="${absoluteBadgeImageUrl}">
   </a>
   <div>
     <label>HTML</label>
     <pre class="swh-badge-html">&lt;a href="${absoluteBadgeLinkUrl}"&gt;
     &lt;img src="${absoluteBadgeImageUrl}"&gt;
 &lt;/a&gt;</pre>
   </div>
   <div>
     <label>Markdown</label>
     <pre class="swh-badge-md">[![SWH](${absoluteBadgeImageUrl})](${absoluteBadgeLinkUrl})</pre>
   </div>
   <div>
     <label>reStructuredText</label>
     <pre class="swh-badge-rst">.. image:: ${absoluteBadgeImageUrl}
     :target: ${absoluteBadgeLinkUrl}</pre>
   </div>`;
   swh.webapp.showModalHtml('Software Heritage badge integration', html);
 }
diff --git a/swh/web/common/identifiers.py b/swh/web/common/identifiers.py
index 0f9b0f12..bf48150d 100644
--- a/swh/web/common/identifiers.py
+++ b/swh/web/common/identifiers.py
@@ -1,383 +1,383 @@
 # Copyright (C) 2020  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 typing import Any, Dict, Iterable, List, Optional, cast
-from urllib.parse import quote
+from urllib.parse import quote, unquote
 
 from typing_extensions import TypedDict
 
 from django.http import QueryDict
 
 from swh.model.exceptions import ValidationError
 from swh.model.hashutil import hash_to_bytes
 from swh.model.identifiers import (
     CONTENT,
     DIRECTORY,
     ORIGIN,
     RELEASE,
     REVISION,
     SNAPSHOT,
     SWHID,
     parse_swhid,
     swhid,
 )
 from swh.web.common import service
 from swh.web.common.exc import BadInputExc
 from swh.web.common.typing import (
     QueryParameters,
     SnapshotContext,
     SWHIDContext,
     SWHIDInfo,
     SWHObjectInfo,
 )
 from swh.web.common.utils import reverse
 
 
 def gen_swhid(
     object_type: str,
     object_id: str,
     scheme_version: int = 1,
     metadata: SWHIDContext = {},
 ) -> str:
     """
     Returns the SoftWare Heritage persistent IDentifier for a swh object based on:
 
         * the object type
         * the object id
         * the SWHID scheme version
 
     Args:
         object_type: the swh object type
             (content/directory/release/revision/snapshot)
         object_id: the swh object id (hexadecimal representation
             of its hash value)
         scheme_version: the scheme version of the SWHIDs
 
     Returns:
         the SWHID of the object
 
     Raises:
         BadInputExc: if the provided parameters do not enable to
             generate a valid identifier
     """
     try:
         obj_swhid = swhid(
             object_type, object_id, scheme_version, cast(Dict[str, Any], metadata)
         )
     except ValidationError as e:
         raise BadInputExc("Invalid object (%s) for SWHID. %s" % (object_id, e))
     else:
         return obj_swhid
 
 
 class ResolvedSWHID(TypedDict):
     """parsed SWHID with context"""
 
     swhid_parsed: SWHID
     """URL to browse object according to SWHID context"""
     browse_url: Optional[str]
 
 
 def resolve_swhid(
     swhid: str, query_params: Optional[QueryParameters] = None
 ) -> ResolvedSWHID:
     """
     Try to resolve a SoftWare Heritage persistent IDentifier into an url for
     browsing the targeted object.
 
     Args:
         swhid: a SoftWare Heritage persistent IDentifier
         query_params: optional dict filled with
             query parameters to append to the browse url
 
     Returns:
         a dict with the following keys:
 
             * **swhid_parsed**: the parsed identifier
             * **browse_url**: the url for browsing the targeted object
     """
     swhid_parsed = get_swhid(swhid)
     object_type = swhid_parsed.object_type
     object_id = swhid_parsed.object_id
     browse_url = None
     url_args = {}
     query_dict = QueryDict("", mutable=True)
     fragment = ""
     anchor_swhid_parsed = None
     process_lines = object_type is CONTENT
 
     if query_params and len(query_params) > 0:
         for k in sorted(query_params.keys()):
             query_dict[k] = query_params[k]
 
     if "origin" in swhid_parsed.metadata:
-        query_dict["origin_url"] = swhid_parsed.metadata["origin"]
+        query_dict["origin_url"] = unquote(swhid_parsed.metadata["origin"])
 
     if "anchor" in swhid_parsed.metadata:
         anchor_swhid_parsed = get_swhid(swhid_parsed.metadata["anchor"])
 
     if "path" in swhid_parsed.metadata and swhid_parsed.metadata["path"] != "/":
-        query_dict["path"] = swhid_parsed.metadata["path"]
+        query_dict["path"] = unquote(swhid_parsed.metadata["path"])
         if anchor_swhid_parsed:
             directory = ""
             if anchor_swhid_parsed.object_type == DIRECTORY:
                 directory = anchor_swhid_parsed.object_id
             elif anchor_swhid_parsed.object_type == REVISION:
                 revision = service.lookup_revision(anchor_swhid_parsed.object_id)
                 directory = revision["directory"]
             elif anchor_swhid_parsed.object_type == RELEASE:
                 release = service.lookup_release(anchor_swhid_parsed.object_id)
                 if release["target_type"] == REVISION:
                     revision = service.lookup_revision(release["target"])
                     directory = revision["directory"]
             if object_type == CONTENT:
                 if "origin" not in swhid_parsed.metadata:
                     # when no origin context, content objects need to have their
                     # path prefixed by root directory id for proper breadcrumbs display
                     query_dict["path"] = directory + query_dict["path"]
                 else:
                     # remove leading slash from SWHID content path
                     query_dict["path"] = query_dict["path"][1:]
             elif object_type == DIRECTORY:
                 object_id = directory
                 # remove leading and trailing slashes from SWHID directory path
                 query_dict["path"] = query_dict["path"][1:-1]
 
     # snapshot context
     if "visit" in swhid_parsed.metadata:
 
         snp_swhid_parsed = get_swhid(swhid_parsed.metadata["visit"])
         if snp_swhid_parsed.object_type != SNAPSHOT:
             raise BadInputExc("Visit must be a snapshot SWHID.")
         query_dict["snapshot"] = snp_swhid_parsed.object_id
 
         if anchor_swhid_parsed:
             if anchor_swhid_parsed.object_type == REVISION:
                 # check if the anchor revision is the tip of a branch
                 branch_name = service.lookup_snapshot_branch_name_from_tip_revision(
                     snp_swhid_parsed.object_id, anchor_swhid_parsed.object_id
                 )
                 if branch_name:
                     query_dict["branch"] = branch_name
                 elif object_type != REVISION:
                     query_dict["revision"] = anchor_swhid_parsed.object_id
 
             elif anchor_swhid_parsed.object_type == RELEASE:
                 release = service.lookup_release(anchor_swhid_parsed.object_id)
                 if release:
                     query_dict["release"] = release["name"]
 
         if object_type == REVISION and "release" not in query_dict:
             branch_name = service.lookup_snapshot_branch_name_from_tip_revision(
                 snp_swhid_parsed.object_id, object_id
             )
             if branch_name:
                 query_dict["branch"] = branch_name
 
     # browsing content or directory without snapshot context
     elif object_type in (CONTENT, DIRECTORY) and anchor_swhid_parsed:
         if anchor_swhid_parsed.object_type == REVISION:
             # anchor revision, objects are browsed from its view
             object_type = REVISION
             object_id = anchor_swhid_parsed.object_id
         elif object_type == DIRECTORY and anchor_swhid_parsed.object_type == DIRECTORY:
             # a directory is browsed from its root
             object_id = anchor_swhid_parsed.object_id
 
     if object_type == CONTENT:
         url_args["query_string"] = f"sha1_git:{object_id}"
     elif object_type == DIRECTORY:
         url_args["sha1_git"] = object_id
     elif object_type == RELEASE:
         url_args["sha1_git"] = object_id
     elif object_type == REVISION:
         url_args["sha1_git"] = object_id
     elif object_type == SNAPSHOT:
         url_args["snapshot_id"] = object_id
     elif object_type == ORIGIN:
         raise BadInputExc(
             (
                 "Origin SWHIDs are not publicly resolvable because they are for "
                 "internal usage only"
             )
         )
 
     if "lines" in swhid_parsed.metadata and process_lines:
         lines = swhid_parsed.metadata["lines"].split("-")
         fragment += "#L" + lines[0]
         if len(lines) > 1:
             fragment += "-L" + lines[1]
 
     if url_args:
         browse_url = (
             reverse(
                 f"browse-{object_type}", url_args=url_args, query_params=query_dict,
             )
             + fragment
         )
 
     return ResolvedSWHID(swhid_parsed=swhid_parsed, browse_url=browse_url)
 
 
 def get_swhid(swhid: str) -> SWHID:
     """Check if a SWHID is valid and return it parsed.
 
         Args:
             swhid: a SoftWare Heritage persistent IDentifier.
 
         Raises:
             BadInputExc: if the provided SWHID can not be parsed.
 
         Return:
             A parsed SWHID.
     """
     try:
         swhid_parsed = parse_swhid(swhid)
     except ValidationError as ve:
         raise BadInputExc("Error when parsing identifier: %s" % " ".join(ve.messages))
     else:
         return swhid_parsed
 
 
 def group_swhids(swhids: Iterable[SWHID],) -> Dict[str, List[bytes]]:
     """
     Groups many SoftWare Heritage persistent IDentifiers into a
     dictionary depending on their type.
 
     Args:
         swhids: an iterable of SoftWare Heritage persistent
             IDentifier objects
 
     Returns:
         A dictionary with:
             keys: object types
             values: object hashes
     """
     swhids_by_type: Dict[str, List[bytes]] = {
         CONTENT: [],
         DIRECTORY: [],
         REVISION: [],
         RELEASE: [],
         SNAPSHOT: [],
     }
 
     for obj_swhid in swhids:
         obj_id = obj_swhid.object_id
         obj_type = obj_swhid.object_type
         swhids_by_type[obj_type].append(hash_to_bytes(obj_id))
 
     return swhids_by_type
 
 
 def get_swhids_info(
     swh_objects: Iterable[SWHObjectInfo],
     snapshot_context: Optional[SnapshotContext] = None,
     extra_context: Optional[Dict[str, Any]] = None,
 ) -> List[SWHIDInfo]:
     """
     Returns a list of dict containing info related to SWHIDs of objects.
 
     Args:
         swh_objects: an iterable of dict describing archived objects
         snapshot_context: optional dict parameter describing the snapshot in
             which the objects have been found
         extra_context: optional dict filled with extra contextual info about
             the objects
 
     Returns:
         a list of dict containing SWHIDs info
 
     """
     swhids_info = []
     for swh_object in swh_objects:
         if not swh_object["object_id"]:
             swhids_info.append(
                 SWHIDInfo(
                     object_type=swh_object["object_type"],
                     object_id="",
                     swhid="",
                     swhid_url="",
                     context={},
                     swhid_with_context=None,
                     swhid_with_context_url=None,
                 )
             )
             continue
         object_type = swh_object["object_type"]
         object_id = swh_object["object_id"]
         swhid_context: SWHIDContext = {}
         if snapshot_context:
             if snapshot_context["origin_info"] is not None:
                 swhid_context["origin"] = quote(
                     snapshot_context["origin_info"]["url"], safe="/?:@&"
                 )
             if object_type != SNAPSHOT:
                 swhid_context["visit"] = gen_swhid(
                     SNAPSHOT, snapshot_context["snapshot_id"]
                 )
             if object_type in (CONTENT, DIRECTORY):
                 if snapshot_context["release_id"] is not None:
                     swhid_context["anchor"] = gen_swhid(
                         RELEASE, snapshot_context["release_id"]
                     )
                 elif snapshot_context["revision_id"] is not None:
                     swhid_context["anchor"] = gen_swhid(
                         REVISION, snapshot_context["revision_id"]
                     )
 
         if object_type in (CONTENT, DIRECTORY):
             if (
                 extra_context
                 and "revision" in extra_context
                 and extra_context["revision"]
                 and "anchor" not in swhid_context
             ):
                 swhid_context["anchor"] = gen_swhid(REVISION, extra_context["revision"])
             elif (
                 extra_context
                 and "root_directory" in extra_context
                 and extra_context["root_directory"]
                 and "anchor" not in swhid_context
                 and (
                     object_type != DIRECTORY
                     or extra_context["root_directory"] != object_id
                 )
             ):
                 swhid_context["anchor"] = gen_swhid(
                     DIRECTORY, extra_context["root_directory"]
                 )
             path = None
             if extra_context and "path" in extra_context:
                 path = extra_context["path"] or "/"
                 if "filename" in extra_context and object_type == CONTENT:
                     path += extra_context["filename"]
             if path:
                 swhid_context["path"] = quote(path, safe="/?:@&")
 
         swhid = gen_swhid(object_type, object_id)
         swhid_url = reverse("browse-swhid", url_args={"swhid": swhid})
 
         swhid_with_context = None
         swhid_with_context_url = None
         if swhid_context:
             swhid_with_context = gen_swhid(
                 object_type, object_id, metadata=swhid_context
             )
             swhid_with_context_url = reverse(
                 "browse-swhid", url_args={"swhid": swhid_with_context}
             )
 
         swhids_info.append(
             SWHIDInfo(
                 object_type=object_type,
                 object_id=object_id,
                 swhid=swhid,
                 swhid_url=swhid_url,
                 context=swhid_context,
                 swhid_with_context=swhid_with_context,
                 swhid_with_context_url=swhid_with_context_url,
             )
         )
     return swhids_info
diff --git a/swh/web/templates/includes/show-swhids.html b/swh/web/templates/includes/show-swhids.html
index da5f7982..72eb46fd 100644
--- a/swh/web/templates/includes/show-swhids.html
+++ b/swh/web/templates/includes/show-swhids.html
@@ -1,101 +1,102 @@
 {% comment %}
 Copyright (C) 2017-2020  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 %}
 
 {% if swhids_info %}
 
   <div id="swh-identifiers" style="display: none;">
     {% if swhids_info|length > 1 %}
       <a id="right-handle" class="handle ui-slideouttab-handle ui-slideouttab-handle-rounded"><i class="mdi mdi-link-variant mdi-fw" aria-hidden="true"></i>Permalinks</a>
     {% else %}
       <a id="right-handle" class="handle ui-slideouttab-handle ui-slideouttab-handle-rounded"><i class="mdi mdi-link-variant mdi-fw" aria-hidden="true"></i>Permalink</a>
     {% endif %}
     <div id="swh-identifiers-content">
       <p>
         To reference or cite the objects present in the Software Heritage archive, permalinks based on
         <a href="https://docs.softwareheritage.org/devel/swh-model/persistent-identifiers.html">
           SoftWare Heritage persistent IDentifiers (SWHIDs)
         </a>
         must be used instead of copying and pasting the url from the address bar of the browser (as there is no guarantee the current URI
         scheme will remain the same over time).
         <br/>
         <br/>
         Select below a type of object currently browsed in order to display its associated SWHID and permalink.
       </p>
 
       <ul class="nav nav-pills ml-auto p-2">
         {% for swhid_info in swhids_info %}
           {% if forloop.first %}
             <li class="nav-item">
               <a class="nav-link active" href="#swhid-tab-{{ swhid_info.object_type }}" data-toggle="tab" onclick="swh.browse.swhIdObjectTypeToggled(event)">
                 <i class="{{ swh_object_icons|key_value:swhid_info.object_type }} mdi-fw" aria-hidden="true"></i>{{ swhid_info.object_type }}
               </a>
             </li>
           {% else %}
             <li class="nav-item">
               <a class="nav-link" href="#swhid-tab-{{ swhid_info.object_type }}" data-toggle="tab" onclick="swh.browse.swhIdObjectTypeToggled(event)">
                   <i class="{{ swh_object_icons|key_value:swhid_info.object_type }} mdi-fw" aria-hidden="true"></i>{{ swhid_info.object_type }}
               </a>
             </li>
           {% endif %}
         {% endfor %}
       </ul>
 
       <div class="tab-content">
         {% for swhid_info in swhids_info %}
           {% if forloop.first %}
             <div class="tab-pane active" id="swhid-tab-{{ swhid_info.object_type }}">
           {% else %}
             <div class="tab-pane" id="swhid-tab-{{ swhid_info.object_type }}">
           {% endif %}
             <div class="card">
               <div class="card-body swhid-ui">
                 {% if snapshot_context and snapshot_context.origin_info %}
                   <img class="swh-badge swh-badge-origin" src="{% url 'swh-badge' 'origin' snapshot_context.origin_info.url %}"
                        onclick="swh.webapp.showBadgeInfoModal('origin', '{{ snapshot_context.origin_info.url|urlencode:"/?:@&" }}')"
                        title="Click to display badge integration info">
                 {% endif %}
                 {% if swhid_info.object_id %}
                   <img class="swh-badge swh-badge-{{ swhid_info.object_type }}" src="{% url 'swh-badge' swhid_info.object_type swhid_info.object_id %}"
                       onclick="swh.webapp.showBadgeInfoModal('{{ swhid_info.object_type }}', $(this).parent().find('.swhid').text())"
                       title="Click to display badge integration info">
                   <pre><a class="swhid" id="{{ swhid_info.swhid }}" href="{{ swhid_info.swhid_url }}">{{ swhid_info.swhid }}</a></pre>
                 {% endif %}
                 {% if swhid_info.swhid_with_context is not None %}
                   <div class="float-left">
                     <form id="swhid-options">
                       <div class="custom-control custom-checkbox swhid-option">
                         <input class="custom-control-input swhid-context-option" value="option-origin" type="checkbox"
                               id="swhid-context-option-{{ swhid_info.object_type }}"
                               data-swhid-with-context="{{ swhid_info.swhid_with_context }}"
+                              data-swhid-with-context-url="{{ swhid_info.swhid_with_context_url }}"
                               onclick="swh.browse.swhIdContextOptionToggled(event)">
                         <label class="custom-control-label font-weight-normal" for="swhid-context-option-{{ swhid_info.object_type }}">Add contextual information</label>
                       </div>
                     </form>
                   </div>
                 {% endif %}
                 <div class="float-right">
                   <button type="button" class="btn btn-default btn-sm btn-swhid-copy"
                           title="Copy SWHID to clipboard">
                     <i class="mdi mdi-content-copy mdi-fw" aria-hidden="true"></i>Copy identifier
                   <button type="button" class="btn btn-default btn-sm btn-swhid-url-copy"
                           title="Copy url resolving the SWHID to clipboard">
                     <i class="mdi mdi-content-copy mdi-fw" aria-hidden="true"></i>Copy permalink
                   </button>
                 </div>
               </div>
             </div>
           </div>
         {% endfor %}
       </div>
     </div>
   </div>
   <script>
     swh.webapp.setSwhIdsContext({{ swhids_info|jsonify }});
   </script>
 {% endif %}
diff --git a/swh/web/tests/browse/views/test_identifiers.py b/swh/web/tests/browse/views/test_identifiers.py
index f1e351a1..f639954c 100644
--- a/swh/web/tests/browse/views/test_identifiers.py
+++ b/swh/web/tests/browse/views/test_identifiers.py
@@ -1,200 +1,212 @@
 # Copyright (C) 2018-2020  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 random
+from urllib.parse import quote
 
 from hypothesis import given
 
-from swh.model.identifiers import CONTENT, REVISION, SNAPSHOT
+from swh.model.identifiers import CONTENT, DIRECTORY, RELEASE, REVISION, SNAPSHOT
 from swh.web.common.identifiers import gen_swhid
 from swh.web.common.utils import reverse
 from swh.web.tests.django_asserts import assert_contains
 from swh.web.tests.strategies import (
     content,
     directory,
     origin,
     release,
     revision,
     snapshot,
 )
 
-swhid_prefix = "swh:1:"
-
 
 @given(content())
 def test_content_id_browse(client, content):
     cnt_sha1_git = content["sha1_git"]
-    swhid = swhid_prefix + "cnt:" + cnt_sha1_git
+    swhid = gen_swhid(CONTENT, cnt_sha1_git)
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     query_string = "sha1_git:" + cnt_sha1_git
     content_browse_url = reverse(
         "browse-content", url_args={"query_string": query_string}
     )
 
     resp = client.get(url)
 
     assert resp.status_code == 302
     assert resp["location"] == content_browse_url
 
 
 @given(directory())
 def test_directory_id_browse(client, directory):
-    swhid = swhid_prefix + "dir:" + directory
+    swhid = gen_swhid(DIRECTORY, directory)
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     directory_browse_url = reverse("browse-directory", url_args={"sha1_git": directory})
 
     resp = client.get(url)
 
     assert resp.status_code == 302
     assert resp["location"] == directory_browse_url
 
 
 @given(revision())
 def test_revision_id_browse(client, revision):
-    swhid = swhid_prefix + "rev:" + revision
+    swhid = gen_swhid(REVISION, revision)
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     revision_browse_url = reverse("browse-revision", url_args={"sha1_git": revision})
 
     resp = client.get(url)
 
     assert resp.status_code == 302
     assert resp["location"] == revision_browse_url
 
     query_params = {"origin_url": "https://github.com/user/repo"}
 
     url = reverse("browse-swhid", url_args={"swhid": swhid}, query_params=query_params)
 
     revision_browse_url = reverse(
         "browse-revision", url_args={"sha1_git": revision}, query_params=query_params
     )
 
     resp = client.get(url)
     assert resp.status_code == 302
     assert resp["location"] == revision_browse_url
 
 
 @given(release())
 def test_release_id_browse(client, release):
-    swhid = swhid_prefix + "rel:" + release
+    swhid = gen_swhid(RELEASE, release)
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     release_browse_url = reverse("browse-release", url_args={"sha1_git": release})
 
     resp = client.get(url)
 
     assert resp.status_code == 302
     assert resp["location"] == release_browse_url
 
     query_params = {"origin_url": "https://github.com/user/repo"}
 
     url = reverse("browse-swhid", url_args={"swhid": swhid}, query_params=query_params)
 
     release_browse_url = reverse(
         "browse-release", url_args={"sha1_git": release}, query_params=query_params
     )
 
     resp = client.get(url)
     assert resp.status_code == 302
     assert resp["location"] == release_browse_url
 
 
 @given(snapshot())
 def test_snapshot_id_browse(client, snapshot):
-    swhid = swhid_prefix + "snp:" + snapshot
+    swhid = gen_swhid(SNAPSHOT, snapshot)
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     snapshot_browse_url = reverse("browse-snapshot", url_args={"snapshot_id": snapshot})
 
     resp = client.get(url)
 
     assert resp.status_code == 302
     assert resp["location"] == snapshot_browse_url
 
     query_params = {"origin_url": "https://github.com/user/repo"}
 
     url = reverse("browse-swhid", url_args={"swhid": swhid}, query_params=query_params)
 
     release_browse_url = reverse(
         "browse-snapshot", url_args={"snapshot_id": snapshot}, query_params=query_params
     )
 
     resp = client.get(url)
     assert resp.status_code == 302
     assert resp["location"] == release_browse_url
 
 
 @given(release())
 def test_bad_id_browse(client, release):
-    swhid = swhid_prefix + "foo:" + release
+    swhid = f"swh:1:foo:{release}"
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     resp = client.get(url)
     assert resp.status_code == 400
 
 
 @given(content())
 def test_content_id_optional_parts_browse(client, content):
     cnt_sha1_git = content["sha1_git"]
-    optional_parts = ";lines=4-20;origin=https://github.com/user/repo"
-    swhid = swhid_prefix + "cnt:" + cnt_sha1_git + optional_parts
+    origin_url = "https://github.com/user/repo"
+    swhid = gen_swhid(
+        CONTENT, cnt_sha1_git, metadata={"lines": "4-20", "origin": origin_url},
+    )
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     query_string = "sha1_git:" + cnt_sha1_git
     content_browse_url = reverse(
         "browse-content",
         url_args={"query_string": query_string},
-        query_params={"origin_url": "https://github.com/user/repo"},
+        query_params={"origin_url": origin_url},
     )
     content_browse_url += "#L4-L20"
 
     resp = client.get(url)
 
     assert resp.status_code == 302
     assert resp["location"] == content_browse_url
 
 
 @given(release())
 def test_origin_id_not_resolvable(client, release):
     swhid = "swh:1:ori:8068d0075010b590762c6cb5682ed53cb3c13deb"
     url = reverse("browse-swhid", url_args={"swhid": swhid})
     resp = client.get(url)
     assert resp.status_code == 400
 
 
 @given(origin())
 def test_legacy_swhid_browse(archive_data, client, origin):
     snapshot = archive_data.snapshot_get_latest(origin["url"])
     revision = archive_data.snapshot_get_head(snapshot)
     directory = archive_data.revision_get(revision)["directory"]
     directory_content = archive_data.directory_ls(directory)
     directory_file = random.choice(
         [e for e in directory_content if e["type"] == "file"]
     )
     legacy_swhid = gen_swhid(
         CONTENT,
         directory_file["checksums"]["sha1_git"],
         metadata={"origin": origin["url"]},
     )
 
     url = reverse("browse-swhid", url_args={"swhid": legacy_swhid})
     resp = client.get(url)
     assert resp.status_code == 302
 
     resp = client.get(resp["location"])
 
     swhid = gen_swhid(
         CONTENT,
         directory_file["checksums"]["sha1_git"],
         metadata={
             "origin": origin["url"],
             "visit": gen_swhid(SNAPSHOT, snapshot),
             "anchor": gen_swhid(REVISION, revision),
         },
     )
 
     assert_contains(resp, swhid)
+
+
+@given(directory())
+def test_browse_swhid_special_characters_escaping(client, directory):
+    origin = "http://example.org/?project=abc;"
+    origin_swhid_escaped = quote(origin, safe="/?:@&")
+    origin_swhid_url_escaped = quote(origin, safe="/:@;")
+    swhid = gen_swhid(DIRECTORY, directory, metadata={"origin": origin_swhid_escaped})
+    url = reverse("browse-swhid", url_args={"swhid": swhid})
+    resp = client.get(url)
+    assert origin_swhid_url_escaped in resp["location"]
diff --git a/swh/web/tests/common/test_identifiers.py b/swh/web/tests/common/test_identifiers.py
index fde1f65b..624b458c 100644
--- a/swh/web/tests/common/test_identifiers.py
+++ b/swh/web/tests/common/test_identifiers.py
@@ -1,576 +1,607 @@
 # Copyright (C) 2020  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 random
+from urllib.parse import quote
 
 from hypothesis import given
 import pytest
 
 from swh.model.hashutil import hash_to_bytes
-from swh.model.identifiers import CONTENT, DIRECTORY, RELEASE, REVISION, SNAPSHOT, SWHID
+from swh.model.identifiers import (
+    CONTENT,
+    DIRECTORY,
+    RELEASE,
+    REVISION,
+    SNAPSHOT,
+    SWHID,
+    parse_swhid,
+)
 from swh.web.browse.snapshot_context import get_snapshot_context
 from swh.web.common.exc import BadInputExc
 from swh.web.common.identifiers import (
     gen_swhid,
     get_swhid,
     get_swhids_info,
     group_swhids,
     resolve_swhid,
 )
 from swh.web.common.typing import SWHObjectInfo
 from swh.web.common.utils import reverse
 from swh.web.tests.data import random_sha1
 from swh.web.tests.strategies import (
     content,
     directory,
     directory_with_subdirs,
     origin,
     origin_with_multiple_visits,
     release,
     revision,
     snapshot,
 )
 
 
 @given(content())
 def test_gen_swhid(content):
     swh_object_type = CONTENT
     sha1_git = content["sha1_git"]
 
     expected_swhid = "swh:1:cnt:" + sha1_git
 
     assert gen_swhid(swh_object_type, sha1_git) == expected_swhid
 
     with pytest.raises(BadInputExc) as e:
         gen_swhid("foo", sha1_git)
     assert e.match("Invalid object")
 
     with pytest.raises(BadInputExc) as e:
         gen_swhid(swh_object_type, "not a valid id")
     assert e.match("Invalid object")
 
 
 @given(content(), directory(), release(), revision(), snapshot())
 def test_resolve_swhid_legacy(content, directory, release, revision, snapshot):
     for obj_type, obj_id in (
         (CONTENT, content["sha1_git"]),
         (DIRECTORY, directory),
         (RELEASE, release),
         (REVISION, revision),
         (SNAPSHOT, snapshot),
     ):
 
         swhid = gen_swhid(obj_type, obj_id)
 
         url_args = {}
         if obj_type == CONTENT:
             url_args["query_string"] = f"sha1_git:{obj_id}"
         elif obj_type == SNAPSHOT:
             url_args["snapshot_id"] = obj_id
         else:
             url_args["sha1_git"] = obj_id
         query_params = {"origin_url": "some-origin"}
         browse_url = reverse(
             f"browse-{obj_type}", url_args=url_args, query_params=query_params
         )
 
         resolved_swhid = resolve_swhid(swhid, query_params)
 
         assert isinstance(resolved_swhid["swhid_parsed"], SWHID)
         assert str(resolved_swhid["swhid_parsed"]) == swhid
         assert resolved_swhid["browse_url"] == browse_url
 
     with pytest.raises(BadInputExc, match="Origin SWHIDs"):
         resolve_swhid(f"swh:1:ori:{random_sha1()}")
 
 
 @given(content(), directory(), release(), revision(), snapshot())
 def test_get_swhid(content, directory, release, revision, snapshot):
     for obj_type, obj_id in (
         (CONTENT, content["sha1_git"]),
         (DIRECTORY, directory),
         (RELEASE, release),
         (REVISION, revision),
         (SNAPSHOT, snapshot),
     ):
         swhid = gen_swhid(obj_type, obj_id)
         swh_parsed_swhid = get_swhid(swhid)
 
         assert isinstance(swh_parsed_swhid, SWHID)
         assert str(swh_parsed_swhid) == swhid
 
     with pytest.raises(BadInputExc, match="Error when parsing identifier"):
         get_swhid("foo")
 
 
 @given(content(), directory(), release(), revision(), snapshot())
 def test_group_swhids(content, directory, release, revision, snapshot):
     swhids = []
     expected = {}
     for obj_type, obj_id in (
         (CONTENT, content["sha1_git"]),
         (DIRECTORY, directory),
         (RELEASE, release),
         (REVISION, revision),
         (SNAPSHOT, snapshot),
     ):
         swhid = gen_swhid(obj_type, obj_id)
         swhid = get_swhid(swhid)
         swhids.append(swhid)
         expected[obj_type] = [hash_to_bytes(obj_id)]
 
     swhid_groups = group_swhids(swhids)
 
     assert swhid_groups == expected
 
 
 @given(directory_with_subdirs())
 def test_get_swhids_info_directory_context(archive_data, directory):
     extra_context = {"path": "/"}
     swhid = get_swhids_info(
         [SWHObjectInfo(object_type=DIRECTORY, object_id=directory)],
         snapshot_context=None,
         extra_context=extra_context,
     )[0]
     swhid_dir_parsed = get_swhid(swhid["swhid_with_context"])
 
     assert swhid_dir_parsed.metadata == extra_context
 
     dir_content = archive_data.directory_ls(directory)
     dir_subdirs = [e for e in dir_content if e["type"] == "dir"]
     dir_subdir = random.choice(dir_subdirs)
     dir_subdir_path = f'/{dir_subdir["name"]}/'
 
     dir_subdir_content = archive_data.directory_ls(dir_subdir["target"])
     dir_subdir_files = [e for e in dir_subdir_content if e["type"] == "file"]
 
     swh_objects_info = [
         SWHObjectInfo(object_type=DIRECTORY, object_id=dir_subdir["target"])
     ]
 
     extra_context = {
         "root_directory": directory,
         "path": dir_subdir_path,
     }
 
     if dir_subdir_files:
         dir_subdir_file = random.choice(dir_subdir_files)
         extra_context["filename"] = dir_subdir_file["name"]
         swh_objects_info.append(
             SWHObjectInfo(
                 object_type=CONTENT, object_id=dir_subdir_file["checksums"]["sha1_git"]
             )
         )
 
     swhids = get_swhids_info(
         swh_objects_info, snapshot_context=None, extra_context=extra_context,
     )
 
     swhid_dir_parsed = get_swhid(swhids[0]["swhid_with_context"])
 
     anchor = gen_swhid(DIRECTORY, directory)
 
     assert swhid_dir_parsed.metadata == {
         "anchor": anchor,
         "path": dir_subdir_path,
     }
 
     if dir_subdir_files:
         swhid_cnt_parsed = get_swhid(swhids[1]["swhid_with_context"])
 
         assert swhid_cnt_parsed.metadata == {
             "anchor": anchor,
             "path": f'{dir_subdir_path}{dir_subdir_file["name"]}',
         }
 
 
 @given(revision())
 def test_get_swhids_info_revision_context(archive_data, revision):
     revision_data = archive_data.revision_get(revision)
     directory = revision_data["directory"]
     dir_content = archive_data.directory_ls(directory)
     dir_entry = random.choice(dir_content)
 
     swh_objects = [
         SWHObjectInfo(object_type=REVISION, object_id=revision),
         SWHObjectInfo(object_type=DIRECTORY, object_id=directory),
     ]
 
     extra_context = {"revision": revision, "path": "/"}
     if dir_entry["type"] == "file":
         swh_objects.append(
             SWHObjectInfo(
                 object_type=CONTENT, object_id=dir_entry["checksums"]["sha1_git"]
             )
         )
         extra_context["filename"] = dir_entry["name"]
 
     swhids = get_swhids_info(
         swh_objects, snapshot_context=None, extra_context=extra_context,
     )
 
     assert swhids[0]["context"] == {}
     swhid_dir_parsed = get_swhid(swhids[1]["swhid_with_context"])
 
     anchor = gen_swhid(REVISION, revision)
 
     assert swhid_dir_parsed.metadata == {
         "anchor": anchor,
         "path": "/",
     }
 
     if dir_entry["type"] == "file":
         swhid_cnt_parsed = get_swhid(swhids[2]["swhid_with_context"])
         assert swhid_cnt_parsed.metadata == {
             "anchor": anchor,
             "path": f'/{dir_entry["name"]}',
         }
 
 
 @given(origin_with_multiple_visits())
 def test_get_swhids_info_origin_snapshot_context(archive_data, origin):
     """
     Test SWHIDs with contextual info computation under a variety of origin / snapshot
     browsing contexts.
     """
 
     visits = archive_data.origin_visit_get(origin["url"])
 
     for visit in visits:
         snapshot = archive_data.snapshot_get(visit["snapshot"])
         snapshot_id = snapshot["id"]
         branches = {
             k: v["target"]
             for k, v in snapshot["branches"].items()
             if v["target_type"] == "revision"
         }
         releases = {
             k: v["target"]
             for k, v in snapshot["branches"].items()
             if v["target_type"] == "release"
         }
         head_rev_id = archive_data.snapshot_get_head(snapshot)
         head_rev = archive_data.revision_get(head_rev_id)
         root_dir = head_rev["directory"]
         dir_content = archive_data.directory_ls(root_dir)
         dir_files = [e for e in dir_content if e["type"] == "file"]
         dir_file = random.choice(dir_files)
         revision_log = [r["id"] for r in archive_data.revision_log(head_rev_id)]
 
         branch_name = random.choice(list(branches))
         release = random.choice(list(releases))
         release_data = archive_data.release_get(releases[release])
         release_name = release_data["name"]
         revision_id = random.choice(revision_log)
 
         for snp_ctx_params, anchor_info in (
             (
                 {"snapshot_id": snapshot_id},
                 {"anchor_type": REVISION, "anchor_id": head_rev_id},
             ),
             (
                 {"snapshot_id": snapshot_id, "branch_name": branch_name},
                 {"anchor_type": REVISION, "anchor_id": branches[branch_name]},
             ),
             (
                 {"snapshot_id": snapshot_id, "release_name": release_name},
                 {"anchor_type": RELEASE, "anchor_id": releases[release]},
             ),
             (
                 {"snapshot_id": snapshot_id, "revision_id": revision_id},
                 {"anchor_type": REVISION, "anchor_id": revision_id},
             ),
             (
                 {"origin_url": origin["url"], "snapshot_id": snapshot_id},
                 {"anchor_type": REVISION, "anchor_id": head_rev_id},
             ),
             (
                 {
                     "origin_url": origin["url"],
                     "snapshot_id": snapshot_id,
                     "branch_name": branch_name,
                 },
                 {"anchor_type": REVISION, "anchor_id": branches[branch_name]},
             ),
             (
                 {
                     "origin_url": origin["url"],
                     "snapshot_id": snapshot_id,
                     "release_name": release_name,
                 },
                 {"anchor_type": RELEASE, "anchor_id": releases[release]},
             ),
             (
                 {
                     "origin_url": origin["url"],
                     "snapshot_id": snapshot_id,
                     "revision_id": revision_id,
                 },
                 {"anchor_type": REVISION, "anchor_id": revision_id},
             ),
         ):
 
             snapshot_context = get_snapshot_context(**snp_ctx_params)
 
             rev_id = head_rev_id
             if "branch_name" in snp_ctx_params:
                 rev_id = branches[branch_name]
             elif "release_name" in snp_ctx_params:
                 rev_id = release_data["target"]
             elif "revision_id" in snp_ctx_params:
                 rev_id = revision_id
 
             swh_objects = [
                 SWHObjectInfo(
                     object_type=CONTENT, object_id=dir_file["checksums"]["sha1_git"]
                 ),
                 SWHObjectInfo(object_type=DIRECTORY, object_id=root_dir),
                 SWHObjectInfo(object_type=REVISION, object_id=rev_id),
                 SWHObjectInfo(object_type=SNAPSHOT, object_id=snapshot_id),
             ]
 
             if "release_name" in snp_ctx_params:
                 swh_objects.append(
                     SWHObjectInfo(object_type=RELEASE, object_id=release_data["id"])
                 )
 
             swhids = get_swhids_info(
                 swh_objects,
                 snapshot_context,
                 extra_context={"path": "/", "filename": dir_file["name"]},
             )
 
             swhid_cnt_parsed = get_swhid(swhids[0]["swhid_with_context"])
             swhid_dir_parsed = get_swhid(swhids[1]["swhid_with_context"])
             swhid_rev_parsed = get_swhid(swhids[2]["swhid_with_context"])
 
             swhid_snp_parsed = get_swhid(
                 swhids[3]["swhid_with_context"] or swhids[3]["swhid"]
             )
 
             swhid_rel_parsed = None
             if "release_name" in snp_ctx_params:
                 swhid_rel_parsed = get_swhid(swhids[4]["swhid_with_context"])
 
             anchor = gen_swhid(
                 object_type=anchor_info["anchor_type"],
                 object_id=anchor_info["anchor_id"],
             )
 
             snapshot_swhid = gen_swhid(object_type=SNAPSHOT, object_id=snapshot_id)
 
             expected_cnt_context = {
                 "visit": snapshot_swhid,
                 "anchor": anchor,
                 "path": f'/{dir_file["name"]}',
             }
 
             expected_dir_context = {
                 "visit": snapshot_swhid,
                 "anchor": anchor,
                 "path": "/",
             }
 
             expected_rev_context = {"visit": snapshot_swhid}
 
             expected_snp_context = {}
 
             if "origin_url" in snp_ctx_params:
                 expected_cnt_context["origin"] = origin["url"]
                 expected_dir_context["origin"] = origin["url"]
                 expected_rev_context["origin"] = origin["url"]
                 expected_snp_context["origin"] = origin["url"]
 
             assert swhid_cnt_parsed.metadata == expected_cnt_context
             assert swhid_dir_parsed.metadata == expected_dir_context
             assert swhid_rev_parsed.metadata == expected_rev_context
             assert swhid_snp_parsed.metadata == expected_snp_context
 
             if "release_name" in snp_ctx_params:
                 assert swhid_rel_parsed.metadata == expected_rev_context
 
 
 @given(origin(), directory())
-def test_get_swhids_info_path_encoding(archive_data, origin, directory):
+def test_get_swhids_info_characters_and_url_escaping(archive_data, origin, directory):
     snapshot_context = get_snapshot_context(origin_url=origin["url"])
     snapshot_context["origin_info"]["url"] = "http://example.org/?project=abc;def%"
     path = "/foo;/bar%"
 
-    swhid = get_swhids_info(
+    swhid_info = get_swhids_info(
         [SWHObjectInfo(object_type=DIRECTORY, object_id=directory)],
         snapshot_context=snapshot_context,
         extra_context={"path": path},
     )[0]
 
-    assert swhid["context"]["origin"] == "http://example.org/?project%3Dabc%3Bdef%25"
-    assert swhid["context"]["path"] == "/foo%3B/bar%25"
+    # check special characters in SWHID have been escaped
+    assert (
+        swhid_info["context"]["origin"] == "http://example.org/?project%3Dabc%3Bdef%25"
+    )
+    assert swhid_info["context"]["path"] == "/foo%3B/bar%25"
+
+    # check special characters in SWHID URL have been escaped
+    parsed_url_swhid = parse_swhid(swhid_info["swhid_with_context_url"][1:-1])
+    assert (
+        parsed_url_swhid.metadata["origin"]
+        == "http://example.org/%3Fproject%253Dabc%253Bdef%2525"
+    )
+    assert parsed_url_swhid.metadata["path"] == "/foo%253B/bar%2525"
 
 
 @given(origin_with_multiple_visits())
 def test_resolve_swhids_snapshot_context(client, archive_data, origin):
     visits = archive_data.origin_visit_get(origin["url"])
     visit = random.choice(visits)
     snapshot = archive_data.snapshot_get(visit["snapshot"])
     head_rev_id = archive_data.snapshot_get_head(snapshot)
 
     branch_info = None
     release_info = None
     for branch_name in sorted(snapshot["branches"]):
         target_type = snapshot["branches"][branch_name]["target_type"]
         target = snapshot["branches"][branch_name]["target"]
         if target_type == "revision" and branch_info is None:
             branch_info = {"name": branch_name, "revision": target}
         elif target_type == "release" and release_info is None:
             release_info = {"name": branch_name, "release": target}
         if branch_info and release_info:
             break
 
     release_info["name"] = archive_data.release_get(release_info["release"])["name"]
 
     directory = archive_data.revision_get(branch_info["revision"])["directory"]
     directory_content = archive_data.directory_ls(directory)
     directory_subdirs = [e for e in directory_content if e["type"] == "dir"]
     directory_subdir = None
     if directory_subdirs:
         directory_subdir = random.choice(directory_subdirs)
     directory_files = [e for e in directory_content if e["type"] == "file"]
     directory_file = None
     if directory_files:
         directory_file = random.choice(directory_files)
     random_rev_id = random.choice(archive_data.revision_log(head_rev_id))["id"]
 
     for snp_ctx_params in (
         {},
         {"branch_name": branch_info["name"]},
         {"release_name": release_info["name"]},
         {"revision_id": random_rev_id},
     ):
         snapshot_context = get_snapshot_context(
             snapshot["id"], origin["url"], **snp_ctx_params
         )
 
         _check_resolved_swhid_browse_url(SNAPSHOT, snapshot["id"], snapshot_context)
 
         rev = head_rev_id
         if "branch_name" in snp_ctx_params:
             rev = branch_info["revision"]
         if "revision_id" in snp_ctx_params:
             rev = random_rev_id
 
         _check_resolved_swhid_browse_url(REVISION, rev, snapshot_context)
 
         _check_resolved_swhid_browse_url(
             DIRECTORY, directory, snapshot_context, path="/"
         )
 
         if directory_subdir:
             _check_resolved_swhid_browse_url(
                 DIRECTORY,
                 directory_subdir["target"],
                 snapshot_context,
                 path=f"/{directory_subdir['name']}/",
             )
 
         if directory_file:
             _check_resolved_swhid_browse_url(
                 CONTENT,
                 directory_file["target"],
                 snapshot_context,
                 path=f"/{directory_file['name']}",
             )
 
             _check_resolved_swhid_browse_url(
                 CONTENT,
                 directory_file["target"],
                 snapshot_context,
                 path=f"/{directory_file['name']}",
                 lines="10",
             )
 
             _check_resolved_swhid_browse_url(
                 CONTENT,
                 directory_file["target"],
                 snapshot_context,
                 path=f"/{directory_file['name']}",
                 lines="10-20",
             )
 
 
 def _check_resolved_swhid_browse_url(
     object_type, object_id, snapshot_context, path=None, lines=None
 ):
     snapshot_id = snapshot_context["snapshot_id"]
     origin_url = None
     if snapshot_context["origin_info"]:
         origin_url = snapshot_context["origin_info"]["url"]
 
     obj_context = {}
     query_params = {}
 
     if origin_url:
         obj_context["origin"] = origin_url
         query_params["origin_url"] = origin_url
 
     obj_context["visit"] = gen_swhid(SNAPSHOT, snapshot_id)
     query_params["snapshot"] = snapshot_id
 
     if object_type in (CONTENT, DIRECTORY, REVISION):
         if snapshot_context["release"]:
             obj_context["anchor"] = gen_swhid(RELEASE, snapshot_context["release_id"])
             query_params["release"] = snapshot_context["release"]
         else:
             obj_context["anchor"] = gen_swhid(REVISION, snapshot_context["revision_id"])
             if (
                 snapshot_context["branch"]
                 and snapshot_context["branch"] != snapshot_context["revision_id"]
             ):
                 branch = snapshot_context["branch"]
                 if branch == "HEAD":
                     for b in snapshot_context["branches"]:
                         if (
                             b["revision"] == snapshot_context["revision_id"]
                             and b["name"] != "HEAD"
                         ):
                             branch = b["name"]
                             break
 
                 query_params["branch"] = branch
             elif object_type != REVISION:
                 query_params["revision"] = snapshot_context["revision_id"]
 
     if path:
         obj_context["path"] = path
         if path != "/":
             if object_type == CONTENT:
                 query_params["path"] = path[1:]
             else:
                 query_params["path"] = path[1:-1]
 
     if object_type == DIRECTORY:
         object_id = snapshot_context["root_directory"]
 
     if lines:
         obj_context["lines"] = lines
 
     obj_swhid = gen_swhid(object_type, object_id, metadata=obj_context)
 
     obj_swhid_resolved = resolve_swhid(obj_swhid)
 
     url_args = {"sha1_git": object_id}
     if object_type == CONTENT:
         url_args = {"query_string": f"sha1_git:{object_id}"}
     elif object_type == SNAPSHOT:
         url_args = {"snapshot_id": object_id}
 
     expected_url = reverse(
         f"browse-{object_type}", url_args=url_args, query_params=query_params,
     )
     if lines:
         lines_number = lines.split("-")
         expected_url += f"#L{lines_number[0]}"
         if len(lines_number) > 1:
             expected_url += f"-L{lines_number[1]}"
 
     assert obj_swhid_resolved["browse_url"] == expected_url
+
+
+@given(directory())
+def test_resolve_swhid_with_escaped_chars(directory):
+    origin = "http://example.org/?project=abc;"
+    origin_swhid_escaped = quote(origin, safe="/?:@&")
+    origin_swhid_url_escaped = quote(origin, safe="/:@;")
+    swhid = gen_swhid(DIRECTORY, directory, metadata={"origin": origin_swhid_escaped})
+    resolved_swhid = resolve_swhid(swhid)
+    assert resolved_swhid["swhid_parsed"].metadata["origin"] == origin_swhid_escaped
+    assert origin_swhid_url_escaped in resolved_swhid["browse_url"]