diff --git a/lib/utils/blob-service.js b/lib/utils/blob-service.js
index 6abd8e098..9cc5984a7 100644
--- a/lib/utils/blob-service.js
+++ b/lib/utils/blob-service.js
@@ -1,62 +1,60 @@
 // @flow
 
 import invariant from 'invariant';
 
+import { replacePathParams, type URLPathParams } from './url-utils.js';
 import type { BlobServiceHTTPEndpoint } from '../facts/blob-service.js';
 import blobServiceConfig from '../facts/blob-service.js';
 
 const BLOB_SERVICE_URI_PREFIX = 'comm-blob-service://';
 
 function makeBlobServiceURI(blobHash: string): string {
   return `${BLOB_SERVICE_URI_PREFIX}${blobHash}`;
 }
 
 function isBlobServiceURI(uri: string): boolean {
   return uri.startsWith(BLOB_SERVICE_URI_PREFIX);
 }
 
 /**
  * Returns the base64url-encoded blob hash from a blob service URI.
  * Throws an error if the URI is not a blob service URI.
  */
 function blobHashFromBlobServiceURI(uri: string): string {
   invariant(isBlobServiceURI(uri), 'Not a blob service URI');
   return uri.slice(BLOB_SERVICE_URI_PREFIX.length);
 }
 
 /**
  * Returns the base64url-encoded blob hash from a blob service URI.
  * Returns null if the URI is not a blob service URI.
  */
 function blobHashFromURI(uri: string): ?string {
   if (!isBlobServiceURI(uri)) {
     return null;
   }
   return blobHashFromBlobServiceURI(uri);
 }
 
 function makeBlobServiceEndpointURL(
   endpoint: BlobServiceHTTPEndpoint,
-  params: { +[name: string]: string } = {},
+  params: URLPathParams = {},
 ): string {
-  let path = endpoint.path;
-  for (const name in params) {
-    path = path.replace(`:${name}`, params[name]);
-  }
+  const path = replacePathParams(endpoint.path, params);
   return `${blobServiceConfig.url}${path}`;
 }
 
 function getBlobFetchableURL(blobHash: string): string {
   return makeBlobServiceEndpointURL(blobServiceConfig.httpEndpoints.GET_BLOB, {
     blobHash,
   });
 }
 
 export {
   makeBlobServiceURI,
   isBlobServiceURI,
   blobHashFromURI,
   blobHashFromBlobServiceURI,
   getBlobFetchableURL,
   makeBlobServiceEndpointURL,
 };
diff --git a/lib/utils/url-utils.js b/lib/utils/url-utils.js
index 8914404cc..0a520a42a 100644
--- a/lib/utils/url-utils.js
+++ b/lib/utils/url-utils.js
@@ -1,118 +1,127 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import { idSchemaRegex, tID, tShape } from './validation-utils.js';
 import { pendingThreadIDRegex } from '../shared/thread-utils.js';
 
 export type URLInfo = {
   +year?: number,
   +month?: number, // 1-indexed
   +verify?: string,
   +calendar?: boolean,
   +chat?: boolean,
   +thread?: string,
   +settings?: 'account' | 'danger-zone',
   +threadCreation?: boolean,
   +selectedUserList?: $ReadOnlyArray<string>,
   +inviteSecret?: string,
   +qrCode?: boolean,
   ...
 };
 
 export const urlInfoValidator: TInterface<URLInfo> = tShape<URLInfo>({
   year: t.maybe(t.Number),
   month: t.maybe(t.Number),
   verify: t.maybe(t.String),
   calendar: t.maybe(t.Boolean),
   chat: t.maybe(t.Boolean),
   thread: t.maybe(tID),
   settings: t.maybe(t.enums.of(['account', 'danger-zone'])),
   threadCreation: t.maybe(t.Boolean),
   selectedUserList: t.maybe(t.list(t.String)),
   inviteSecret: t.maybe(t.String),
   qrCode: t.maybe(t.Boolean),
 });
 
 // We use groups to capture parts of the URL and any changes
 // to regexes must be reflected in infoFromURL.
 const yearRegex = new RegExp('(/|^)year/([0-9]+)(/|$)', 'i');
 const monthRegex = new RegExp('(/|^)month/([0-9]+)(/|$)', 'i');
 const threadRegex = new RegExp(`(/|^)thread/(${idSchemaRegex})(/|$)`, 'i');
 const verifyRegex = new RegExp('(/|^)verify/([a-f0-9]+)(/|$)', 'i');
 const calendarRegex = new RegExp('(/|^)calendar(/|$)', 'i');
 const chatRegex = new RegExp('(/|^)chat(/|$)', 'i');
 const accountSettingsRegex = new RegExp('(/|^)settings/account(/|$)', 'i');
 const dangerZoneRegex = new RegExp('(/|^)settings/danger-zone(/|$)', 'i');
 const threadPendingRegex = new RegExp(
   `(/|^)thread/(${pendingThreadIDRegex})(/|$)`,
   'i',
 );
 const threadCreationRegex = new RegExp(
   '(/|^)thread/new(/([0-9]+([+][0-9]+)*))?(/|$)',
   'i',
 );
 const inviteLinkRegex = new RegExp(
   '(/|^)handle/invite/([a-zA-Z0-9]+)(/|$)',
   'i',
 );
 const qrCodeLoginRegex = new RegExp('(/|^)qr-code(/|$)', 'i');
 
 function infoFromURL(url: string): URLInfo {
   const yearMatches = yearRegex.exec(url);
   const monthMatches = monthRegex.exec(url);
   const threadMatches = threadRegex.exec(url);
   const verifyMatches = verifyRegex.exec(url);
   const calendarTest = calendarRegex.test(url);
   const chatTest = chatRegex.test(url);
   const accountSettingsTest = accountSettingsRegex.test(url);
   const dangerZoneTest = dangerZoneRegex.test(url);
   const threadPendingMatches = threadPendingRegex.exec(url);
   const threadCreateMatches = threadCreationRegex.exec(url);
   const inviteLinkMatches = inviteLinkRegex.exec(url);
   const qrCodeLoginMatches = qrCodeLoginRegex.exec(url);
 
   const returnObj = {};
   if (yearMatches) {
     returnObj.year = parseInt(yearMatches[2], 10);
   }
   if (monthMatches) {
     const month = parseInt(monthMatches[2], 10);
     if (month < 1 || month > 12) {
       throw new Error('invalid_month');
     }
     returnObj.month = month;
   }
   if (threadMatches) {
     returnObj.thread = threadMatches[2];
   }
   if (threadPendingMatches) {
     returnObj.thread = threadPendingMatches[2];
   }
   if (threadCreateMatches) {
     returnObj.threadCreation = true;
     returnObj.selectedUserList = threadCreateMatches[3]?.split('+') ?? [];
   }
   if (verifyMatches) {
     returnObj.verify = verifyMatches[2];
   }
   if (inviteLinkMatches) {
     returnObj.inviteSecret = inviteLinkMatches[2];
   }
   if (calendarTest) {
     returnObj.calendar = true;
   } else if (chatTest) {
     returnObj.chat = true;
   } else if (accountSettingsTest) {
     returnObj.settings = 'account';
   } else if (dangerZoneTest) {
     returnObj.settings = 'danger-zone';
   } else if (qrCodeLoginMatches) {
     returnObj.qrCode = true;
   }
   return returnObj;
 }
 
 const setURLPrefix = 'SET_URL_PREFIX';
 
-export { infoFromURL, setURLPrefix };
+export type URLPathParams = { +[name: string]: string };
+
+function replacePathParams(path: string, params: URLPathParams = {}): string {
+  for (const name in params) {
+    path = path.replace(`:${name}`, params[name]);
+  }
+  return path;
+}
+
+export { infoFromURL, setURLPrefix, replacePathParams };