How to Install Exiftool on Ubuntu 26.04, 24.04 and 22.04

Metadata work gets easier when one terminal command can inspect camera tags, PDF fields, sidecar files, media timestamps, and privacy-sensitive location data. To install ExifTool on Ubuntu, use the Ubuntu package libimage-exiftool-perl for routine work, then add the separate upstream archive only when you need a newer ExifTool release than your Ubuntu version currently ships.

The Ubuntu APT package provides the normal exiftool command. The upstream archive path in this article creates exiftool-latest under your user account, so it does not replace Ubuntu’s package-managed /usr/bin/exiftool. The commands apply to Ubuntu 26.04, 24.04, and 22.04.

Install ExifTool on Ubuntu

Choose the package source first. Both install paths can coexist because they use different command names, but most systems should start with the Ubuntu package and add exiftool-latest only for newer upstream metadata support.

Choose an ExifTool Install Method

Method	Source	Command	Update behavior	Best for
Ubuntu APT package	Ubuntu Universe package libimage-exiftool-perl	exiftool	APT upgrades with your Ubuntu release	Most users who want predictable system maintenance
Manual upstream archive	Official ExifTool archive and checksum file	exiftool-latest	Manual rerun when upstream publishes a newer release	Users who need newer tag or file-format support without changing system files
Optional update helper	Same official upstream archive path as the manual method	update-exiftool-latest	Repeats the archive check, checksum verification, replacement, and no-op detection	Users who expect to refresh the upstream archive more than once

Current Ubuntu package metadata lists ExifTool 13.50 on Ubuntu 26.04, 12.76 on Ubuntu 24.04, and 12.40 on Ubuntu 22.04. Upstream can be newer than the archive package; run exiftool -ver or exiftool-latest -ver after installation to confirm the active command.

These commands use sudo for package-manager steps that change system packages. Review the LinuxCapable sudo command examples if your account cannot run administrator commands yet.

Install ExifTool with APT

Refresh package metadata, then install the Ubuntu package. APT places the command at /usr/bin/exiftool and tracks it with the rest of your Ubuntu packages.

sudo apt update
sudo apt install libimage-exiftool-perl

Verify the version, command path, and package owner after the install finishes.

exiftool -ver
command -v exiftool
dpkg -S "$(command -v exiftool)"

Relevant output from a successful APT install includes the package-managed path and owner:

/usr/bin/exiftool
libimage-exiftool-perl: /usr/bin/exiftool

Install Latest ExifTool Manually from the Upstream Archive

Use the upstream archive method when the Ubuntu package is too old for a tag, file type, or ExifTool fix you need. This method uses the official ExifTool site, the project-published SourceForge archive path, and the official checksum file before replacing the user-local install directory.

The manual archive method replaces only ~/.local/opt/exiftool-latest and ~/.local/bin/exiftool-latest. Back up those paths first if you already use them for a custom ExifTool install.

Install the download prerequisites if they are missing. Ubuntu normally includes the archive tools, but wget and CA certificates are the pieces this path depends on directly.

The archive workflow uses wget for upstream downloads. The LinuxCapable wget command examples are useful if you want to review output redirection and quiet download flags before adapting the commands.

sudo apt update
sudo apt install wget ca-certificates

Create a temporary working directory, download the current upstream archive, and verify it against ExifTool’s published SHA-256 checksum.

workdir="$(mktemp -d)"
cd "$workdir"

version="$(wget -qO- https://exiftool.org/ver.txt | tr -d '[:space:]')"
archive="Image-ExifTool-${version}.tar.gz"

wget -O "$archive" "https://downloads.sourceforge.net/project/exiftool/${archive}"

expected_sha256="$(wget -qO- https://exiftool.org/checksums.txt | grep -o "SHA2-256(${archive})= [0-9a-f]*" | awk '{print $2}')"
if [ -z "$expected_sha256" ]; then
  echo "Checksum not found for $archive" >&2
  exit 1
fi

printf '%s  %s\n' "$expected_sha256" "$archive" | sha256sum -c -

Example output from a verified archive looks like this. The version changes when upstream publishes a newer release.

Image-ExifTool-13.59.tar.gz: OK

Extract the verified archive, move it into a stable user-local directory, and create the exiftool-latest wrapper. The wrapper runs the extracted ExifTool script in place so the bundled lib directory stays next to it.

install_dir="$HOME/.local/opt/exiftool-latest"
wrapper="$HOME/.local/bin/exiftool-latest"

gzip -dc "$archive" | tar -xf -
mkdir -p "$(dirname "$install_dir")" "$(dirname "$wrapper")"

rm -rf -- "$install_dir"
mv "Image-ExifTool-${version}" "$install_dir"

cat > "$wrapper" <<'WRAPPER'
#!/bin/sh
exec "$HOME/.local/opt/exiftool-latest/exiftool" "$@"
WRAPPER

chmod +x "$wrapper"

Add ~/.local/bin to your current shell path if the directory was created during this session, then verify the wrapper.

export PATH="$HOME/.local/bin:$PATH"
command -v exiftool-latest
exiftool-latest -ver

Example output should show a path under your home directory and the upstream version. The username portion of the path will differ on your system.

/home/joshua/.local/bin/exiftool-latest
13.59

Remove the temporary download directory after the wrapper works.

cd "$HOME"
if [ -n "${workdir:-}" ] && [ -d "$workdir" ]; then
  rm -rf -- "$workdir"
fi

Create an Optional Upstream Update Helper

The helper in this section is not a separate package source. It automates the same official archive download, checksum check, extraction, wrapper creation, and no-op detection used by the manual method. Keep the manual commands above when you want to see each phase; use the helper when you expect to refresh exiftool-latest repeatedly.

mkdir -p "$HOME/.local/bin"

cat > "$HOME/.local/bin/update-exiftool-latest" <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

install_dir="$HOME/.local/opt/exiftool-latest"
bin_dir="$HOME/.local/bin"
wrapper="$bin_dir/exiftool-latest"
base_url="https://exiftool.org"
download_base="https://downloads.sourceforge.net/project/exiftool"

require_command() {
  local name="$1"
  if ! command -v "$name" >/dev/null 2>&1; then
    printf 'Missing required command: %s\n' "$name" >&2
    exit 1
  fi
}

for name in wget gzip tar sha256sum awk grep mktemp; do
  require_command "$name"
done

latest="$(wget -qO- "$base_url/ver.txt" | tr -d '[:space:]')"
if [[ -z "$latest" || ! "$latest" =~ ^[0-9]+([.][0-9]+)+$ ]]; then
  printf 'Could not parse the latest ExifTool version.\n' >&2
  exit 1
fi

current="not installed"
if [[ -x "$wrapper" ]]; then
  current="$($wrapper -ver 2>/dev/null || printf 'broken')"
elif command -v exiftool-latest >/dev/null 2>&1; then
  current="$(exiftool-latest -ver 2>/dev/null || printf 'broken')"
fi

printf 'Latest ExifTool version: %s\n' "$latest"
printf 'Current exiftool-latest version: %s\n' "$current"

if [[ "$current" == "$latest" && -x "$wrapper" && -x "$install_dir/exiftool" ]]; then
  printf 'exiftool-latest is already current.\n'
  printf 'Command path: %s\n' "$wrapper"
  exit 0
fi

tmp_dir=""
cleanup() {
  if [[ -n "${tmp_dir:-}" ]]; then
    rm -rf -- "$tmp_dir"
  fi
}
trap cleanup EXIT

tmp_dir="$(mktemp -d)"
archive="Image-ExifTool-${latest}.tar.gz"
archive_path="$tmp_dir/$archive"

wget -qO "$archive_path" "$download_base/$archive"
expected_sha256="$(wget -qO- "$base_url/checksums.txt" | grep -o "SHA2-256(${archive})= [0-9a-f]*" | awk '{print $2}')"
if [[ -z "$expected_sha256" ]]; then
  printf 'Checksum not found for %s\n' "$archive" >&2
  exit 1
fi

(
  cd "$tmp_dir"
  printf '%s  %s\n' "$expected_sha256" "$archive" | sha256sum -c -
)

gzip -dc "$archive_path" | tar -C "$tmp_dir" -xf -
staging_dir="$tmp_dir/Image-ExifTool-$latest"
if [[ ! -x "$staging_dir/exiftool" || ! -d "$staging_dir/lib" ]]; then
  printf 'The extracted ExifTool archive did not contain the expected files.\n' >&2
  exit 1
fi

mkdir -p "$(dirname "$install_dir")" "$bin_dir"
rm -rf -- "$install_dir"
mv "$staging_dir" "$install_dir"

cat > "$wrapper" <<'WRAPPER'
#!/bin/sh
exec "$HOME/.local/opt/exiftool-latest/exiftool" "$@"
WRAPPER
chmod +x "$wrapper"

printf 'Installed exiftool-latest %s\n' "$($wrapper -ver)"
printf 'Command path: %s\n' "$wrapper"
EOF

chmod +x "$HOME/.local/bin/update-exiftool-latest"
export PATH="$HOME/.local/bin:$PATH"
command -v update-exiftool-latest

The command discovery check should print the helper path under ~/.local/bin. Run the helper to install or update the upstream archive:

update-exiftool-latest

Example first-run output includes the version check, checksum result, installed version, and command path:

Latest ExifTool version: 13.59
Current exiftool-latest version: not installed
Image-ExifTool-13.59.tar.gz: OK
Installed exiftool-latest 13.59
Command path: /home/joshua/.local/bin/exiftool-latest

Run the helper again later to check for an upstream update. A current install exits without replacing files:

update-exiftool-latest

Latest ExifTool version: 13.59
Current exiftool-latest version: 13.59
exiftool-latest is already current.
Command path: /home/joshua/.local/bin/exiftool-latest

Check ExifTool Metadata Output

The examples in this section use exiftool. Replace it with exiftool-latest when you want to test the upstream archive install instead of the Ubuntu package.

Read Basic File Metadata

Start with a harmless system text file so you can confirm ExifTool works before pointing it at photos, documents, or media files.

exiftool -FileName -Directory -MIMEType /etc/os-release

File Name                       : os-release
Directory                       : /etc
MIME Type                       : text/plain

Export Selected Metadata as JSON

Use JSON output when you want to hand metadata to a script, compare records, or store a small audit file.

exiftool -j -FileName -Directory -MIMEType /etc/os-release > metadata.json
cat metadata.json

[{
  "SourceFile": "/etc/os-release",
  "FileName": "os-release",
  "Directory": "/etc",
  "MIMEType": "text/plain"
}]

Create and Inspect an XMP Sidecar

This example creates a small XMP sidecar file from /etc/os-release, then reads back the fields you set. It is safer than practicing on original photos because it creates a new file in your current directory.

exiftool -XMP-dc:Creator="Your Name" -XMP-dc:Description="Metadata note" -o example.xmp /etc/os-release
exiftool -Creator -Description example.xmp

Creator                         : Your Name
Description                     : Metadata note

Remove Metadata from a Copy

Practice metadata removal on a copy first. This workflow keeps the original example.xmp and removes metadata from cleaned-example.xmp.

cp example.xmp cleaned-example.xmp
exiftool -overwrite_original -all= cleaned-example.xmp

For photos or documents, review the cleaned file before replacing the original. Metadata can include useful camera, rights, timestamp, geolocation, and workflow fields, not just private information.

Remove the practice files when you no longer need them.

rm -f -- metadata.json example.xmp cleaned-example.xmp

Update ExifTool on Ubuntu

Update the APT Package

For the Ubuntu package, refresh package metadata and ask APT to upgrade only libimage-exiftool-perl if your release has a newer build available.

sudo apt update
sudo apt install --only-upgrade libimage-exiftool-perl

Relevant output on a current Ubuntu 26.04 system looks like this:

libimage-exiftool-perl is already the newest version (13.50+dfsg-1).
0 upgraded, 0 newly installed, 0 to remove and 5 not upgraded.

The exact version and upgrade counts can differ by release and enabled repositories. The important signal is that APT handles the package and either upgrades it or reports it is already current for your Ubuntu sources.

Check the Manual Archive Version

For the manual archive method, compare the installed wrapper version with the latest upstream version. If they differ, rerun the manual download, checksum, extraction, and wrapper commands from the archive section.

latest="$(wget -qO- https://exiftool.org/ver.txt | tr -d '[:space:]')"
installed="$(exiftool-latest -ver)"
printf 'latest=%s installed=%s\n' "$latest" "$installed"

latest=13.59 installed=13.59

This is the manual update check for the archive install. Matching values mean your exiftool-latest wrapper already runs the newest upstream release available from ExifTool’s version file.

Update with the Helper Script

If you created update-exiftool-latest, run that command instead of repeating the manual archive blocks. The helper checks the upstream version, verifies the checksum, replaces the user-local archive only when needed, and reports the no-op state when you are already current.

update-exiftool-latest

Latest ExifTool version: 13.59
Current exiftool-latest version: 13.59
exiftool-latest is already current.
Command path: /home/joshua/.local/bin/exiftool-latest

Remove ExifTool from Ubuntu

Remove the APT Package

Remove the Ubuntu package when you no longer need the package-managed exiftool command.

sudo apt remove libimage-exiftool-perl

Confirm the command and package are gone from the installed package set.

hash -r
command -v exiftool || echo "exiftool removed"
dpkg -l libimage-exiftool-perl 2>/dev/null | grep '^ii' || echo "APT package removed"

exiftool removed
APT package removed

APT may report dependencies that are no longer required. Review the package list before accepting an autoremove cleanup, especially on reused workstations.

sudo apt autoremove

Remove the User-Local Archive Install

This removes the user-local upstream archive, wrapper, and optional updater helper. It does not remove the Ubuntu APT package, and it permanently deletes those local ExifTool helper paths for your account.

rm -rf -- "$HOME/.local/opt/exiftool-latest" "$HOME/.local/bin/exiftool-latest" "$HOME/.local/bin/update-exiftool-latest"
hash -r
command -v exiftool-latest || echo "exiftool-latest removed"
command -v update-exiftool-latest || echo "update-exiftool-latest removed"

exiftool-latest removed
update-exiftool-latest removed

Troubleshoot ExifTool on Ubuntu

Fix exiftool: command not found

The APT method provides exiftool; the upstream archive method provides exiftool-latest. Check both command names before reinstalling anything.

for cmd in exiftool exiftool-latest update-exiftool-latest; do
  if command -v "$cmd" >/dev/null 2>&1; then
    printf '%s -> %s\n' "$cmd" "$(command -v "$cmd")"
  else
    printf '%s -> not found\n' "$cmd"
  fi
done

exiftool -> /usr/bin/exiftool
exiftool-latest -> /home/joshua/.local/bin/exiftool-latest
update-exiftool-latest -> /home/joshua/.local/bin/update-exiftool-latest

If exiftool-latest exists under ~/.local/bin but your current shell cannot find it, add that directory to the current shell path and retry the version check.

export PATH="$HOME/.local/bin:$PATH"
exiftool-latest -ver

Fix APT Unable to Locate the Package

libimage-exiftool-perl is in Ubuntu’s Universe component. Check the package candidate first; a missing candidate usually means Universe is disabled or package metadata is stale.

apt-cache policy libimage-exiftool-perl

Relevant output should include a candidate version, such as the Ubuntu 26.04 package shown here:

libimage-exiftool-perl:
  Installed: (none)
  Candidate: 13.50+dfsg-1
  Version table:
     13.50+dfsg-1 500
        500 http://archive.ubuntu.com/ubuntu resolute/universe amd64 Packages

If the candidate is (none), enable Universe, refresh package metadata, and recheck the package candidate before installing.

sudo apt install software-properties-common
sudo add-apt-repository --yes universe
sudo apt update
apt-cache policy libimage-exiftool-perl

Fix a Failed Upstream Checksum

Stop when checksum verification fails. A mismatch means the downloaded archive does not match the checksum ExifTool publishes for that version, or the script resolved mismatched version and checksum data.

version="$(wget -qO- https://exiftool.org/ver.txt | tr -d '[:space:]')"
archive="Image-ExifTool-${version}.tar.gz"
wget -qO- https://exiftool.org/checksums.txt | grep -F "SHA2-256(${archive})="

SHA2-256(Image-ExifTool-13.59.tar.gz)= 668ea3acececb7235fbd0f4900e72d5f12c9b07e5c778fd36cb1e9b5828fd65a

Remove the failed working directory and rerun the download. Do not extract or install the archive until sha256sum -c - reports OK.

cd "$HOME"
if [ -n "${workdir:-}" ] && [ -d "$workdir" ]; then
  rm -rf -- "$workdir"
fi

Fix a Broken exiftool-latest Wrapper

If exiftool-latest exists but fails to run, check both the wrapper and the extracted upstream script. Both should be executable.

test -x "$HOME/.local/bin/exiftool-latest" && echo "wrapper executable"
test -x "$HOME/.local/opt/exiftool-latest/exiftool" && echo "upstream script executable"

wrapper executable
upstream script executable

If either line is missing, rerun the manual archive install or run update-exiftool-latest after confirming the helper exists. Retest with exiftool-latest -ver.

Use Upstream When the APT Version Is Too Old

Ubuntu LTS releases prioritize stable package branches over every upstream ExifTool release. If a tag, file type, or metadata fix requires a newer upstream release, use exiftool-latest for that task and keep the APT package for normal system-managed use.

Conclusion

ExifTool is ready on Ubuntu when exiftool -ver reports the Ubuntu package version or exiftool-latest -ver reports the upstream archive version. Keep APT as the default maintenance path, and use the separate upstream wrapper or helper only when newer metadata support is worth the extra manual ownership.