diff --git a/express.js b/express.js
index 912f2a0f47..75d5d60289 100644
--- a/express.js
+++ b/express.js
@@ -26,9 +26,7 @@ app.get(`${process.env.DIR || ''}/api/provider/:provider?`, api)
 
 app.post(`${process.env.DIR || ''}/api/provider/:provider?`, express.json({ limit: '5mb' }), api)
 
-app.get(`${process.env.DIR || ''}/api/sign/:provider?`, api)
-
-app.post(`${process.env.DIR || ''}/api/sign/:provider?`, express.json({ limit: '5mb' }), api)
+app.get(`${process.env.DIR || ''}/api/sign/:signer?`, api)
 
 
 app.get(`${process.env.DIR || ''}/api/query/:template?`, api)
diff --git a/lib/ui/locations/entries/cloudinary.mjs b/lib/ui/locations/entries/cloudinary.mjs
index 578f869802..07031bb326 100644
--- a/lib/ui/locations/entries/cloudinary.mjs
+++ b/lib/ui/locations/entries/cloudinary.mjs
@@ -1,20 +1,22 @@
-const types = {
-  image,
-  images,
-  documents
-}
+/**
+## /ui/locations/entries/cloudinary
 
-const onload = {
-  image: imageLoad,
-  images: imageLoad,
-  documents: docLoad
-}
+The cloudinary module exports a method to upload or destroy resources with signed requests on cloudinary.
+
+The exported method creates an interface in the location view with input for images and documents.
+
+@requires /utils/xhr
+@requires /utils/imagePreview
+
+@module /ui/locations/entries/cloudinary
+*/
 
 mapp.utils.merge(mapp.dictionaries, {
   en: {
     image_upload_failed: 'Image upload failed.',
     document_upload_failed: 'Document upload failed.',
-    remove_item_confirm: 'Remove item?'
+    remove_image_confirm: 'Are you sure to remove the image? This cannot be undone.',
+    remove_document_confirm: 'Are you sure to remove this document? This cannot be undone.'
   },
   de: {
     image_upload_failed: 'Hochladen des Bildes gescheitert.',
@@ -58,112 +60,141 @@ mapp.utils.merge(mapp.dictionaries, {
   }
 })
 
+const types = {
+  image,
+  images,
+  documents
+}
+
 export default entry => types[entry.type](entry)
 
-function image(entry) {
+/**
+@function image
 
-  if (entry.value) {
+@description
+The image entry.type function returns an image with a button to detroy the image the entry has a value and is editable.
 
-    const trashBtn = mapp.utils.html`
-      <button 
-        style="position: absolute; width: 2em; height: 2em; right: 0.5em; top: 0.5em;"
-        class="mask-icon trash no"
-        data-name=${entry.value.replace(/^.*\//, '').replace(/\.([\w-]{3})/, '')}
-        data-src=${entry.value}
-        onclick=${e => trash(e, entry)}>`
-
-    // Render image with src from cloudinary reference as value.
-    return mapp.utils.html.node`
-      <div style="position: relative;">
-        <img
-          style="width: 100%"
-          src=${entry.value}
-          onclick=${mapp.ui.utils.imagePreview}>
-          ${entry.edit && trashBtn}`
+@param {Object} entry 
+@property {string} entry.value An existing cloudinary resource URL.
+@property {Object} entry.edit The entry is editable.
 
-  }
+@returns {HTMLElement} Returns either an image element or an input element to upload an image.
+*/
+function image(entry) {
 
-  if (entry.edit) {
+  if (entry.value) {
 
-    return mapp.utils.html.node`
-      <input
-        type="file"
-        accept="image/*;capture=camera"
-        onchange=${e => upload(e, entry)}>`
+    // The trash button will only be created when entry is editable.
+    const trashBtn = entry.edit && mapp.utils.html`<button 
+      class="mask-icon trash no"
+      data-name=${entry.value.replace(/^.*\//, '').replace(/\.([\w-]{3})/, '')}
+      data-src=${entry.value}
+      onclick=${e => trash(e, entry, mapp.dictionary.remove_image_confirm)}>`
+
+    return mapp.utils.html.node`<div style="position: relative">
+      <img
+        style="width: 100%"
+        src=${entry.value}
+        onclick=${mapp.ui.utils.imagePreview}>
+        ${trashBtn}`
+
+  } else if (entry.edit) {
+
+    // Return image upload input for editable entry without a value.
+    return mapp.utils.html.node`<input 
+      type=file class="flat bold wide primary-colour"
+      accept="image/*"
+      capture="camera"
+      onchange=${e => upload(e, entry)}>`
   }
 }
 
+/**
+@function images
+
+@description
+The images entry.type function returns an image-grid element of images with the ability to destroy resources if the entry is editable. An input is show to upload additional images if the entry is editable.
+
+@param {Object} entry 
+@property {Array} entry.value An array of existing cloudinary resource URLs.
+@property {Object} entry.edit The entry is editable.
+@returns {HTMLElement} A grid element with existing images and an input to upload additional images on editable entry.
+*/
 function images(entry) {
 
   const images = entry.value?.map(image => {
 
-    const trashBtn = mapp.utils.html`
-      <button
-        class="mask-icon trash no"
-        data-name=${image.replace(/^.*\//, '').replace(/\.([\w-]{3})/, '')}
-        data-src=${image}
-        onclick=${e => trash(e, entry)}>`
+    // The trash button will only be created when entry is editable.
+    const trashBtn = entry.edit && mapp.utils.html`<button
+      class="mask-icon trash no"
+      data-name=${image.replace(/^.*\//, '').replace(/\.([\w-]{3})/, '')}
+      data-src=${image}
+      onclick=${e => trash(e, entry, mapp.dictionary.remove_image_confirm)}>`
 
-    return mapp.utils.html`
-      <div>
-        <img 
-          src=${image}
-          onclick=${mapp.ui.utils.imagePreview}>
-          ${entry.edit && trashBtn}`
+    return mapp.utils.html`<div><img 
+      src=${image}
+      onclick=${mapp.ui.utils.imagePreview}>
+      ${trashBtn}`
 
   }) || []
 
+  // Push upload input into images array.
   if (entry.edit) images.push(mapp.utils.html.node`
     <div class="mask-icon add-photo pos-center">
       <input
         type="file"
-        accept="image/*;capture=camera"
+        accept="image/*"
+        capture="camera"
         onchange=${e => upload(e, entry)}>`)
 
   if (!images.length) return;
 
-  entry.list = mapp.utils.html.node`<div class="images-grid">${images}`
-
-  return entry.list;
+  return mapp.utils.html.node`<div class="images-grid">${images}`
 }
 
+/**
+@function documents
+
+@description
+The documents entry.type function returns an document-list element of documents with the ability to destroy resources if the entry is editable. An input is show to upload additional documents if the entry is editable.
+
+@param {Object} entry 
+@returns {HTMLElement} A list element with existing documents and an input to upload additional documents on editable entry.
+ */
 function documents(entry) {
 
   const docs = entry.value?.map(doc => {
 
-    const trashBtn = mapp.utils.html`
-      <button
-        class="mask-icon trash no"
-        data-name=${doc.replace(/^.*\//, '').replace(/\.([\w-]{3})/, '')}
-        data-href=${doc}
-        onclick=${e => trash(e, entry)}>`
+    const trashBtn = entry.edit && mapp.utils.html`<button
+      class="mask-icon trash no"
+      data-name=${doc.replace(/^.*\//, '').replace(/\.([\w-]{3})/, '')}
+      data-href=${doc}
+      onclick=${e => trash(e, entry, mapp.dictionary.remove_document_confirm)}>`
 
-    return mapp.utils.html`
-      <div class="link-with-img">
-        ${(entry.edit) && trashBtn}
-          <a
-            target="_blank"
-            href=${doc}>${doc.replace(/^.*\//, '').replace(/\.([\w-]{3})/, '')}`
+    return mapp.utils.html`<div class="link-with-img">
+      ${trashBtn}<a target="_blank" href=${doc}>${doc.replace(/^.*\//, '').replace(/\.([\w-]{3})/, '')}`
 
   }) || []
 
-  entry.uploadBtn = mapp.utils.html.node`
-    <div class="mask-icon cloud-upload">
-      <input
-        style="opacity: 0; width: 3em; height: 3em;"
-        type="file"
-        accept=".txt,.pdf,.doc,.docx,.xls,.xlsx,application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document;"
-        onchange=${e => upload(e, entry)}>`
-
-  entry.edit && docs.push(entry.uploadBtn)
+  entry.edit && docs.unshift(mapp.utils.html`<input 
+    type=file class="flat bold wide primary-colour"
+    accept=".txt,.pdf,.doc,.docx,.xls,.xlsx,application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document;"
+    onchange=${e => upload(e, entry)}>`)
 
   if (!docs.length) return;
 
-  entry.list = mapp.utils.html.node`<div>${docs}`
-
-  return entry.list;
+  return mapp.utils.html.node`<div>${docs}`
 }
 
+/**
+@function upload
+
+@description
+The upload event can be assigned to the onchange event of an input to upload the resource selected in the input element.
+
+@param {event} e The onchange event from the input element to select a resource.
+@param {Object} entry  
+*/
 async function upload(e, entry) {
 
   // Location view must disabled while uploading resource.
@@ -175,11 +206,26 @@ async function upload(e, entry) {
 
   entry.file = e.target.files[0]
 
+  const onload = {
+    image: imageLoad,
+    images: imageLoad,
+    documents: docLoad
+  }
+
   reader.onload = e => onload[entry.type](e, entry)
 
   reader.readAsDataURL(entry.file)
 }
 
+/**
+@function imageLoad
+
+@description
+The imageLoad function handles the loading and processing of an image file.
+
+@param {event} e 
+@param {Object} entry 
+*/
 function imageLoad(e, entry) {
 
   const img = new Image()
@@ -207,85 +253,123 @@ function imageLoad(e, entry) {
 
     canvas.getContext('2d').drawImage(img, 0, 0, width, height)
 
-    const dataURL = canvas.toDataURL('image/jpeg', 0.5)
-
-    const public_id = entry.file.name.replace(/^.*\//, '').replace(/\.([\w-]{3})/, '') + entry.suffix_date ? `@${Date.now()}` : '';
-
-    const response = await mapp.utils.xhr({
-      method: 'POST',
-      requestHeader: {
-        'Content-Type': 'application/octet-stream'
-      },
-      url: `${entry.location.layer.mapview.host}/api/provider/cloudinary?${mapp.utils.paramString({
-        public_id,
-        resource_type: 'image',
-        folder: entry.cloudinary_folder
-      })}`,
-      body: mapp.utils.dataURLtoBlob(dataURL)
+    const public_id = entry.file.name
+      .replace(/^.*\//, '')
+      .replace(/\.([\w-]{3})/, '') + entry.suffix_date ? `@${Date.now()}` : '';
+
+    const signedUrl = await getSignedUrl(entry, { public_id })
+
+    // Failed to generate a signedUrl for the request.
+    if (!signedUrl) return;
+
+    const data = new FormData()
+
+    data.append('file', canvas.toDataURL('image/jpeg', 0.5))
+
+    const response = await fetch(signedUrl, {
+      method: 'post',
+      body: data
     })
 
     if (!response || response.error) {
-      const errorDetail = response?.error?.message ? ` Error: ${response.error.message}` : '';
-      const errorMessage = `${mapp.dictionary.image_upload_failed}${errorDetail}`;
-      alert(errorMessage);
+      const errorDetail = response?.error?.message ? `Error: ${response.error.message}` : '';
+      const errorMessage = `Cloudinary Image upload failed! ${errorDetail}`;
+      mapp.ui.elements.alert({ text: errorMessage });
       return;
     }
 
+    const responseJson = await response.json()
+
     if (entry.type === 'image') {
 
       // Only a single image is supported by the entry.type.
-      entry.value = response.secure_url
+      entry.value = responseJson.secure_url
+
     } else {
 
       // Add the secure_url to the entry values array and update the location.
-      entry.value = Array.isArray(entry.value) ? entry.value.concat([response.secure_url]) : [response.secure_url]
+      entry.value = Array.isArray(entry.value) ? entry.value.concat([responseJson.secure_url]) : [responseJson.secure_url]
     }
 
-    postUpdate(entry)
+    updateLocation(entry)
   }
 
   img.src = e.target.result
 }
 
+/**
+@function docLoad
+
+@description
+The docLoad method handles the upload of document files to via signed URL to cloudinary.
+
+@param {event} e 
+@param {Object} entry 
+*/
 async function docLoad(e, entry) {
 
-  const response = await mapp.utils.xhr({
-    method: 'POST',
-    requestHeader: {
-      'Content-Type': 'application/octet-stream'
-    },
-    url: `${entry.location.layer.mapview.host}/api/provider/cloudinary?${mapp.utils.paramString({
-      public_id: entry.file.name,
-      resource_type: 'raw',
-      folder: entry.cloudinary_folder
-    })}`,
-    body: e.target.result
+  const date = new Date();
+  const stamp = `${date.getMonth() + 1}-${date.getDate()}T${date.getHours()}:${date.getMinutes()}`
+  const file_type = entry.file.name.substring(entry.file.name.lastIndexOf('.'))
+  const public_id = `${entry.file.name.replace(file_type, '')}-${stamp}${file_type}`;
+
+  const signedUrl = await getSignedUrl(entry, { public_id })
+
+  // Failed to generate a signedUrl for the request.
+  if (!signedUrl) return;
+
+  const data = new FormData()
+
+  data.append('file', e.target.result.toString())
+
+  const response = await fetch(signedUrl, {
+    method: 'post',
+    body: data
   })
 
   if (!response || response.error) {
-    const errorDetail = response?.error?.message ? ` Error: ${response.error.message}` : '';
-    const errorMessage = `${mapp.dictionary.document_upload_failed}${errorDetail}`;
-    alert(errorMessage);
+    const errorDetail = response?.error?.message ? `Error: ${response.error.message}` : '';
+
+    mapp.ui.elements.alert(`Cloudinary document upload failed! ${errorDetail}`);
     return;
   }
+
   // Add the secure_url to the entry values array and update the location.
-  entry.value = Array.isArray(entry.value) ? entry.value.concat([response.secure_url]) : [response.secure_url]
+  const responseJson = await response.json()
 
-  postUpdate(entry)
+  entry.value = Array.isArray(entry.value)
+    ? entry.value.concat([responseJson.secure_url])
+    : [responseJson.secure_url];
+
+  updateLocation(entry)
 }
 
-async function trash(e, entry) {
+/**
+@function trash
+
+@description
+The trash function handles the deletion an image file.
+
+@param {event} e 
+@param {Object} entry 
+*/
+async function trash(e, entry, confirm_message) {
+
+  const confirm_remove = await mapp.ui.elements.confirm({
+    text: confirm_message
+  })
+
+  if (!confirm_remove) return;
+
+  const public_id = decodeURIComponent(e.target.dataset.name);
 
-  const confirm = await mapp.ui.elements.confirm({ text: mapp.dictionary.remove_item_confirm });
+  const signedUrl = await getSignedUrl(entry, { public_id, destroy: true })
 
-  if (!confirm) return;
+  // Failed to generate a signedUrl for the request.
+  if (!signedUrl) return;
 
   // Send request to cloudinary to destroy resource.
-  await mapp.utils.xhr(`${entry.location.layer.mapview.host}/api/provider/cloudinary?${mapp.utils.paramString({
-    destroy: true,
-    public_id: e.target.dataset.name,
-    folder: entry.cloudinary_folder
-  })}`)
+  await fetch(signedUrl, { method: 'post' })
 
   // Remove the resource link from the entry values array and update the location.
   const valueSet = new Set(entry.value)
@@ -300,18 +384,25 @@ async function trash(e, entry) {
     entry.value = valueSet.size ? Array.from(valueSet) : null;
   }
 
-  postUpdate(entry)
+  updateLocation(entry)
 }
 
-async function postUpdate(entry) {
+/**
+@function updateLocation 
+
+@description
+The method disables the location view before updating the location data and re-creating the cloudinary entry.type interface.
+
+@param {Object} entry
+@property {HTMLElement} entry.node The location view element which holds the cloudinary interface elements.
+*/
+async function updateLocation(entry) {
 
   entry.location.view?.classList.add('disabled')
 
-  // Update the geometry field value.
   await mapp.utils.xhr({
     method: 'POST',
-    url:
-      `${entry.location.layer.mapview.host}/api/query?` +
+    url: `${entry.location.layer.mapview.host}/api/query?` +
       mapp.utils.paramString({
         template: 'location_update',
         locale: entry.location.layer.mapview.locale.key,
@@ -319,14 +410,45 @@ async function postUpdate(entry) {
         table: entry.location.table,
         id: entry.location.id,
       }),
-    body: JSON.stringify({ [entry.field]: entry.value }),
+    body: JSON.stringify({ [entry.field]: entry.value })
   })
 
-  const content = mapp.ui.locations.entries[entry.type](entry)
+  // Render the type interface into the location view entry.node
+  mapp.utils.render(entry.node, types[entry.type](entry))
 
-  mapp.utils.render(entry.node, content)
+  entry.location.view?.classList.remove('disabled')
+}
 
-  entry.title && content.before(mapp.ui.locations.entries.title(entry))
+/**
+@function getSignedUrl
+@async
+@description
+Signs a parameterised request to upload or destroy a resource on cloudinary.
 
-  entry.location.view?.classList.remove('disabled')
-}
\ No newline at end of file
+@param {Object} entry 
+@param {Object} params 
+@property {string} entry.cloudinary_folder
+@property {string} params.public_id
+@property {boolean} [params.destroy] The request is to detroy a stored resource.
+
+@returns {Promise<String>} signedURL
+*/
+async function getSignedUrl(entry, params) {
+
+  const paramString = mapp.utils.paramString({
+    ...params,
+    folder: entry.cloudinary_folder
+  })
+
+  const signedUrl = await mapp.utils.xhr({
+    url: `${entry.location.layer.mapview.host}/api/sign/cloudinary?${paramString}`,
+    responseType: 'text'
+  });
+
+  if (signedUrl instanceof Error) {
+
+    console.error(signedUrl)
+  }
+
+  return signedUrl
+}
diff --git a/lib/ui/utils/imagePreview.mjs b/lib/ui/utils/imagePreview.mjs
index 5c9502daa9..dfce4a2ef3 100644
--- a/lib/ui/utils/imagePreview.mjs
+++ b/lib/ui/utils/imagePreview.mjs
@@ -4,12 +4,25 @@
 @module /ui/utils/imagePreview
 */
 
-export default e => {
 
-  document.body.append(mapp.utils.html.node`
-    <div class="interface-mask">
-      <div class="bg-image" style=${`background-image:url(${e.target.src})`}>
-      <button class="btn-close mask-icon close"
-        onclick=${e => e.target.parentElement.parentElement.remove()}>`);
+/**
+@function imagePreview
+
+@description
+The imagePreview utility method can be assigned to an image element onclick.
+
+@param {Object} e Image element click event. 
+*/
+export default function imagePreview(e) {
+
+  const previewElement = mapp.utils.html.node`
+  <div class="interface-mask">
+    <div
+      class="bg-image" 
+      style=${`background-image:url(${e.target.src})`}>
+    <button 
+      class="btn-close mask-icon close"
+      onclick=${e => e.target.closest('.interface-mask').remove()}>`
 
-}
\ No newline at end of file
+  document.body.append(previewElement);
+}
diff --git a/mod/provider/_provider.js b/mod/provider/_provider.js
index c7d3c863fc..542889c732 100644
--- a/mod/provider/_provider.js
+++ b/mod/provider/_provider.js
@@ -6,15 +6,12 @@ const file = require('./file')
 
 const cloudfront = require('./cloudfront')
 
-const cloudinary = require('./cloudinary')
-
 const s3 = require('./s3')
 
 module.exports = async (req, res) => {
 
   const provider = {
     cloudfront,
-    cloudinary,
     file,
     s3
   }
diff --git a/mod/provider/cloudfront.js b/mod/provider/cloudfront.js
index e30c7f4032..8747d24399 100644
--- a/mod/provider/cloudfront.js
+++ b/mod/provider/cloudfront.js
@@ -1,22 +1,47 @@
 /**
-@module /provider/cloudfront
-*/
+ * @module /provider/cloudfront
+ */
 
 const { readFileSync } = require('fs')
-
 const { join } = require('path')
-
 const { getSignedUrl } = require('@aws-sdk/cloudfront-signer');
-
 const logger = require('../utils/logger')
 
-const nodeFetch = require('node-fetch')
-
-module.exports = async ref => {
-
+/**
+ * Fetches and processes content from CloudFront with signed URLs
+ * @async
+ * @param {Object|string} ref - Reference object or URL string
+ * @param {Object} [ref.params] - Optional parameters for the request
+ * @param {string} [ref.params.url] - URL to fetch from CloudFront
+ * @param {boolean} [ref.params.signedURL] - If true, returns only the signed URL
+ * @param {boolean} [ref.params.buffer] - If true, returns response as buffer
+ * @returns {Promise<string|Object|Buffer|Error>} 
+ *          - String for text responses
+ *          - Object for JSON responses
+ *          - Buffer if buffer parameter is true
+ *          - Error if response status >= 300
+ * @throws {Error} Logs error to console if request fails
+ * 
+ * @example
+ * // Fetch JSON with signed URL
+ * const data = await cloudfront({ 
+ *   params: { 
+ *     url: 'example.com/data.json'
+ *   }
+ * });
+ * 
+ * @example
+ * // Get only signed URL
+ * const signedUrl = await cloudfront({
+ *   params: {
+ *     url: 'example.com/file.txt',
+ *     signedURL: true
+ *   }
+ * });
+ */
+module.exports = async function cloudfront(ref) {
   try {
-
-    // Subtitutes {*} with process.env.SRC_* key values.
+    // Substitutes {*} with process.env.SRC_* key values.
     const url = (ref.params?.url || ref).replace(/{(?!{)(.*?)}/g,
       matched => process.env[`SRC_${matched.replace(/(^{)|(}$)/g, '')}`])
 
@@ -32,13 +57,11 @@ module.exports = async ref => {
 
     // Return signedURL only from request.
     if (ref.params?.signedURL) {
-
       return signedURL;
     }
 
-    const response = await nodeFetch(signedURL)
-
-    logger(`${response.status} - ${url}`,'cloudfront')
+    const response = await fetch(signedURL)
+    logger(`${response.status} - ${url}`, 'cloudfront')
 
     if (response.status >= 300) return new Error(`${response.status} ${ref}`)
 
@@ -48,7 +71,8 @@ module.exports = async ref => {
 
     return await response.text()
 
-  } catch(err) {
+  } catch (err) {
+
     console.error(err)
   }
 
diff --git a/mod/provider/cloudinary.js b/mod/provider/cloudinary.js
deleted file mode 100644
index 54c53eff1c..0000000000
--- a/mod/provider/cloudinary.js
+++ /dev/null
@@ -1,84 +0,0 @@
-/**
-@module /cloudinary
-*/
-
-const { createHash } = require('crypto');
-
-// 1: api_key
-// 2: api_secret
-// 3: cloud_name
-const cloudinary = process.env.CLOUDINARY_URL?.replaceAll('://', ' ').replaceAll(':', ' ').replaceAll('@', ' ').split(' ');
-
-module.exports = async req => {
-
-  if (!cloudinary) {
-    console.warn(`process.env.CLOUDINARY_URL not set`);
-    return;
-  }
-
-  // Destroy cloudinary resource.
-  if (req.params.destroy) return await destroy(req);
-
-  const data = generateData(req, 'upload');
-
-  req.body = req.body && await bodyData(req) || null;
-
-  // Convert body to appropriate format
-  const file = req.params.resource_type === 'raw' ? req.body.toString() : `data:image/jpeg;base64,${req.body.toString('base64')}`;
-  data.append('file', file);
-
-  const response = await fetch(`https://api.cloudinary.com/v1_1/${cloudinary[3]}/upload`, {
-    method: 'post',
-    body: data,
-  });
-
-  return await response.json();
-}
-
-async function destroy(req) {
-  const data = generateData(req, 'destroy');
-  const response = await fetch(`https://api.cloudinary.com/v1_1/${cloudinary[3]}/image/destroy`, {
-    method: 'post',
-    body: data,
-  });
-
-  return await response.json();
-}
-
-function generateData(req, action) {
-  // The timestamp is required for the signature which is valid for 1hr.
-  const timestamp = Date.now();
-  let toSign = '';
-
-  // Define signature string based on the action (upload/destroy)
-  if (action === 'upload') {
-    toSign = `folder=${req.params.folder}&public_id=${req.params.public_id}&timestamp=${timestamp}${cloudinary[2]}`;
-  } else if (action === 'destroy') {
-    toSign = `public_id=${req.params.public_id}&timestamp=${timestamp}${cloudinary[2]}`;
-  }
-
-  const signature = createHash('sha256').update(toSign).digest('hex');
-  const data = new FormData();
-
-  data.append('public_id', req.params.public_id);
-  data.append('api_key', cloudinary[1]);
-  data.append('timestamp', timestamp);
-  data.append('signature', signature);
-
-  // Append folder for upload action
-  if (action === 'upload') {
-    data.append('folder', req.params.folder);
-  }
-
-  return data;
-}
-
-function bodyData(req) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-
-    req.on('data', chunk => chunks.push(chunk));
-    req.on('end', () => resolve(Buffer.concat(chunks)));
-    req.on('error', error => reject(error));
-  });
-}
\ No newline at end of file
diff --git a/mod/sign/_sign.js b/mod/sign/_sign.js
index f3768da543..c6115e62e8 100644
--- a/mod/sign/_sign.js
+++ b/mod/sign/_sign.js
@@ -1,22 +1,47 @@
 /**
+## /sign
+
+The sign module provides access to different request signer methods.
+
+@requires /sign/cloudinary
+
 @module /sign
 */
 
 const cloudinary = require('./cloudinary')
 
-module.exports = async (req, res) => {
+const signerModules = {
+  cloudinary
+}
 
-  const signer = {
-    cloudinary
-  }
+/**
+@function signer
+@async
+
+@description
+The signer method looks up a signerModules method matching the signer request parameter and passes the req/res objects as argument to the matched method.
 
-  if (!Object.hasOwn(signer, req.params.provider)) {
+The response from the method is returned with the HTTP response.
+
+@param {Object} req HTTP request.
+@param {Object} res HTTP response.
+@param {Object} req.params Request parameter.
+@param {string} params.signer Signer module to sign the request.
+
+@returns {Promise} The promise resolves into the response from the signerModules method.
+*/
+module.exports = async function signer(req, res) {
+
+  if (!Object.hasOwn(signerModules, req.params.signer)) {
     return res.send(`Failed to validate 'provider' param.`)
   }
 
-  const response = await signer[req.params.provider](req)
+  const response = await signerModules[req.params.signer](req, res)
 
-  req.params.content_type && res.setHeader('content-type', req.params.content_type)
+  if (response instanceof Error) {
 
+    return res.status(500).send(response.message)
+  }
+    
   res.send(response)
-}
\ No newline at end of file
+}
diff --git a/mod/sign/cloudinary.js b/mod/sign/cloudinary.js
index 2b71eaceae..5fc0488f4f 100644
--- a/mod/sign/cloudinary.js
+++ b/mod/sign/cloudinary.js
@@ -1,33 +1,84 @@
 /**
+### /sign/cloudinary
+
+Exports the cloudinary signer method.
+
+@requires crypto
+
 @module /sign/cloudinary
 */
 
 const { createHash } = require('crypto');
 
-module.exports = async req => {
-    // 1: api_key
-    // 2: api_secret
-    // 3: cloud_name
-    const cloudinary = process.env.CLOUDINARY_URL?.replaceAll('://', ' ').replaceAll(':', ' ').replaceAll('@', ' ').split(' ');
-    const baseUrl = `https://api.cloudinary.com/v1_1/${cloudinary[3]}/`
-
-    const folder = (!req.params.folder) ? '' : `${req.params.folder}/`
-
-    // The timestamp is required for the signature which is valid for 1hr.
-    const timestamp = Date.now();
-    let toSign = '';
-
-    // Define signature string based on the action (upload/destroy)
-    if (!req.params.destroy) {
-        toSign = `folder=${req.params.folder}&public_id=${req.params.public_id}&timestamp=${timestamp}${cloudinary[2]}`;
-
-    } else if (req.params.destroy) {
-        toSign = `public_id=${folder}${req.params.public_id}&timestamp=${timestamp}${cloudinary[2]}`;
-    }
-
-    const signature = createHash('sha256').update(toSign).digest('hex');
-    const params = `${toSign}&signature=${signature}&timestamp=${timestamp}&api_key=${cloudinary[1]}`;
-    const signedUrl = `${baseUrl}${req.params.destroy ? 'image/destroy' : 'upload'}?${params}`
-    
-    return {signedUrl:signedUrl};
-}
\ No newline at end of file
+/**
+@function cloudinary
+@async
+
+@description
+The cloudinary signer method signs requests for the cloudinary service.
+
+The default request for uploading resources to cloudinary.
+
+A request to destroy a resource stored in the cloudinary service can be signed with the destroy request parameter being truthy.
+
+A folder and public_id parameter for resources to be uploaded or destroyed are required.
+
+@param {Object} req HTTP request.
+@param {Object} res HTTP response.
+@param {Object} req.params Request parameter.
+@param {string} params.folder
+@param {string} params.public_id
+@param {string} params.destroy
+
+@returns {Promise} The promise resolves into the response from the signerModules method.
+*/
+module.exports = async function cloudinary(req, res) {
+
+  if (!process.env.CLOUDINARY_URL) return new Error('CLOUDINARY_URL not provided in process.env')
+
+  if (!req.params.folder) return new Error('A folder request param is required for the cloudinary signer.')
+
+  if (!req.params.public_id) return new Error('A public_id request param is required for the cloudinary signer.')
+
+  // Split CLOUDINARY_URL string into array of ['cloudinary', api_key, api_secret, cloud_name]
+  const cloudinary = process.env.CLOUDINARY_URL
+    .replaceAll('://', '|')
+    .replaceAll(':', '|')
+    .replaceAll('@', '|')
+    .split('|');
+
+  const folder = req.params.folder += '/'
+
+  // The timestamp is required for the signature which is valid for 1hr.
+  const timestamp = Date.now();
+
+  const params = [
+    `timestamp=${timestamp}${cloudinary[2]}`
+  ]
+
+  if (req.params.destroy) {
+
+    params.unshift(`public_id=${folder}${req.params.public_id}`)
+  } else {
+
+    // Request is to upload a resource.
+    params.unshift(`public_id=${req.params.public_id}`)
+    params.unshift(`folder=${req.params.folder}`)
+  }
+
+  const toSign = params.join('&')
+
+  const signature = createHash('sha256').update(toSign).digest('hex');
+
+  params.push(`signature=${signature}`)
+
+  params.push(`timestamp=${timestamp}`)
+
+  params.push(`api_key=${cloudinary[1]}`)
+
+  const method = req.params.destroy? 'image/destroy': 'upload';
+
+  const signedUrl = `https://api.cloudinary.com/v1_1/${cloudinary[3]}/${method}?${params.join('&')}`
+
+  return signedUrl;
+}
diff --git a/public/css/_locationview.css b/public/css/_locationview.css
index 319c31b44e..647c32ab36 100644
--- a/public/css/_locationview.css
+++ b/public/css/_locationview.css
@@ -87,6 +87,14 @@
   & .dataview {
     text-align: left;
   }
+
+  >.contents.image .trash {
+    position: absolute;
+    width: 2em;
+    height: 2em;
+    right: 0.5em;
+    top: 0.5em;
+  }
 }
 
 .images-grid {
diff --git a/public/css/ui.css b/public/css/ui.css
index 6120070c19..5d1487cdc2 100644
--- a/public/css/ui.css
+++ b/public/css/ui.css
@@ -1535,6 +1535,13 @@ label.checkbox {
   & .dataview {
     text-align: left;
   }
+  > .contents.image .trash {
+    position: absolute;
+    width: 2em;
+    height: 2em;
+    right: 0.5em;
+    top: 0.5em;
+  }
 }
 .images-grid {
   position: relative;
diff --git a/tests/lib/ui/locations/entries/_entries.test.mjs b/tests/lib/ui/locations/entries/_entries.test.mjs
index ad22f3ef21..cf8185976d 100644
--- a/tests/lib/ui/locations/entries/_entries.test.mjs
+++ b/tests/lib/ui/locations/entries/_entries.test.mjs
@@ -1,9 +1,11 @@
 import { pinTest } from './pin.test.mjs';
 import { geometryTest } from './geometry.test.mjs';
 import { layerTest } from './layer.test.mjs';
+import { cloudinaryTest } from './cloudinary.test.mjs';
 
 export const entriesTest = {
     pinTest,
     geometryTest,
-    layerTest
+    layerTest,
+    cloudinaryTest
 }
\ No newline at end of file
diff --git a/tests/lib/ui/locations/entries/cloudinary.test.mjs b/tests/lib/ui/locations/entries/cloudinary.test.mjs
new file mode 100644
index 0000000000..1052d5839b
--- /dev/null
+++ b/tests/lib/ui/locations/entries/cloudinary.test.mjs
@@ -0,0 +1,100 @@
+/**
+ * @module lib/ui/locations/entries/cloudinary
+ */
+
+/**
+ * Entry point for the cloudinary test module
+ * @function cloudinaryTest 
+ */
+export async function cloudinaryTest() {
+    await codi.describe('UI Entries: Cloudinary', async () => {
+
+        /**
+         * @description Should return image preview
+         * @function it
+         */
+        await codi.it('Should return cloudinary res url for image preview with trash icon', async () => {
+
+            const entry = {
+                title: 'Image', 
+                type: 'image', 
+                cloudinary_folder: 'test', 
+                value: 'https://res.cloudinary.com/dvx8vwneg/image/upload/v1730365463/test/%401730365462823.jpg', 
+                edit: true
+    
+            }
+
+            const imageEntry = mapp.ui.locations.entries.image(entry)
+            
+            codi.assertEqual(imageEntry.children[0].getAttribute('src'), entry.value, 'Image src should be the entrys value');
+            codi.assertTrue(imageEntry.children[1].classList.contains('trash'), 'Image should have a delete button');
+            codi.assertEqual(imageEntry.children[1].getAttribute('data-src'), entry.value, 'Delete button src should match entry value');
+
+        });
+
+        /**
+         * @description Should return document name
+         * @function it
+         */
+        await codi.it('Should return cloudinary res url for document preview with trash icon', async () => {
+
+            const entry = { 
+                            title: 'Documents', 
+                            type: 'documents', 
+                            cloudinary_folder: 'test', 
+                            edit: true,
+                            value: [ 'https://res.cloudinary.com/dvx8vwneg/raw/upload/v1730363322/test/test-10-31T10:28.txt' ] 
+                         }
+            
+
+            const documentEntry = mapp.ui.locations.entries.documents(entry)
+            
+            const linkHolder = documentEntry.children[1]
+            codi.assertEqual(linkHolder.children[1].getAttribute('href'), entry.value[0], 'Document href should be the entrys value');
+            codi.assertTrue(linkHolder.children[0].classList.contains('trash'), 'Document should have a delete button');
+            codi.assertEqual(linkHolder.children[0].getAttribute('data-href'), entry.value[0], 'Delete button src should match entry value');
+
+        });
+
+         /**
+         * @description Should return multiple images in an image grid
+         * @function it
+         */
+        await codi.it('Should return an image grid with trash icons on each', async () => {
+
+            const entry = { 
+                            title: 'Images', 
+                            type: 'images', 
+                            cloudinary_folder: 'test', 
+                            edit: true,
+                            value: [ 
+                                     'https://res.cloudinary.com/dvx8vwneg/image/upload/v1730365463/test/%401730365462823.jpg',
+                                     'https://res.cloudinary.com/dvx8vwneg/image/upload/v1730365463/test/%401730365462823.jpg'
+                                   ] 
+                            }
+            
+
+            const imagesEntry = mapp.ui.locations.entries.images(entry)
+        
+            codi.assertEqual(imagesEntry.children.length, 3, 'Multiple images should appear in the infoj');
+        });
+
+        /**
+         * @description Should return multiple images in an image grid
+         * @function it
+         */
+        await codi.it('Should return an image with no trash icon', async () => {
+
+            const entry = {
+                title: 'Image', 
+                type: 'image', 
+                cloudinary_folder: 'test', 
+                value: 'https://res.cloudinary.com/dvx8vwneg/image/upload/v1730365463/test/%401730365462823.jpg'
+            }
+
+            const imageEntry = mapp.ui.locations.entries.image(entry)
+            
+            codi.assertEqual(imageEntry.children.length, 1, 'Image should not have a delete button');
+        });
+    })
+}
\ No newline at end of file