Rimuovere i metadati EXIF dalle foto prima di inviarle

Le tue foto possono nascondere coordinate GPS precise. Ecco cos'è un metadato EXIF e uno script Python per pulire le immagini in locale, senza cloud.

Scatti una foto dal balcone di casa, la invii via email a un potenziale acquirente su un sito di annunci, e senza saperlo gli hai appena fornito l’indirizzo esatto in cui vivi, con un margine di errore di pochi metri.

Questo avviene a causa dei metadati EXIF (Exchangeable Image File Format). Ogni volta che scatti una foto, lo smartphone non salva solo i pixel: incorpora nel file un blocco di dati invisibile con data e ora, modello del dispositivo e — se la localizzazione è attiva — le coordinate GPS.

Quando carichi una foto su Instagram o la invii come messaggio normale su WhatsApp, queste piattaforme di solito rimuovono i metadati (per spazio e privacy). Se invece invii la foto via email, la carichi su un forum o la mandi come documento/file su Telegram, le coordinate possono viaggiare intatte insieme all’immagine.

Esistono decine di siti «rimuovi EXIF online». Il paradosso è evidente: per proteggere la privacy, finisci per caricare una foto scattata in casa sui server di un servizio che non controlli.

In questa guida costruisci uno strumento locale: Python + Pillow, zero upload.

ℹ️ Nota / Prerequisito operativo
Serve Python già installato sul computer. Percorso principale di questa guida: Windows. I comandi per macOS e Linux sono scritti per intero sotto — non serve aprire altri articoli per completare i passaggi.
Se Python manca ancora: installalo prima (guide dedicate: Windows, macOS, Linux).

---

Scheda tecnica dello script

Prima di scaricare o incollare il codice, ecco cosa fa — e cosa non fa.

💡 Consiglio pratico — Perché Pillow e non solo la libreria standard: su ai riparo preferisco evitare dipendenze esterne quando possibile. Qui Pillow è il compromesso onesto: senza di essa, gestire JPEG/PNG/WebP e orientamento EXIF diventa fragile e poco leggibile.

---

Passaggio 1 — Preparare l’ambiente virtuale

Tutto ciò che serve per arrivare a Pillow installata è in questa sezione. Percorso principale: Windows; subito dopo gli stessi passi per macOS e Linux.

⚠️ Attenzione — Sul Mac pip install nudo spesso «non fa nulla»: fuori dal venv, oppure con un pip che non punta al Python giusto, il comando può fallire in silenzio o installare nel posto sbagliato. Qui uso sempre python -m pip (Windows) e python3 -m pip (macOS/Linux), poi verifico l’import.

1 — Apri il terminale

Windows (principale)

1. Premi il tasto Windows.
2. Digita cmd (Prompt dei comandi) oppure powershell.
3. Apri l’app proposta. Comparirà una finestra nera (o blu) con una riga di testo dove puoi scrivere.

macOS

1. Apri Spotlight (Cmd + Spazio).
2. Digita Terminale e premi Invio.
3. Si apre una finestra con il prompt (di solito termina con % o $).

Linux

1. Apri l’app Terminale / Console dal menu della distro (su molte Ubuntu: Ctrl + Alt + T).
2. Comparirà un prompt che di solito termina con $.

2 — Crea la cartella e entraci

Scegli un posto comodo (Documenti va bene). Esempio di nome cartella: pulizia-foto.

Windows — Prompt dei comandi:

cd %USERPROFILE%\Documents
mkdir pulizia-foto
cd pulizia-foto

Windows — PowerShell:

cd $env:USERPROFILE\Documents
mkdir pulizia-foto
cd pulizia-foto

macOS:

cd ~/Documents
mkdir pulizia-foto
cd pulizia-foto

Linux:

cd ~/Documents
mkdir -p pulizia-foto
cd pulizia-foto

Controllo: digita cd (Windows) oppure pwd (macOS/Linux) e premi Invio: il percorso mostrato deve finire con pulizia-foto.

💡 Trucco drag & drop: digita cd + spazio, poi trascina la cartella dalla finestra file dentro il terminale e premi Invio. Il percorso si completa da solo.

3 — Crea il venv (cartella ambiente isolato)

Il venv è una cartellina .venv che contiene una copia «isolata» di Python: Pillow finirà lì dentro, non nell’installazione globale del sistema.

Windows:

python -m venv .venv

macOS / Linux:

python3 -m venv .venv

Aspetta qualche secondo. Spesso non compare alcun messaggio di successo: è normale.
Se compare No module named venv o python / python3 non riconosciuto: Python non è installato correttamente (o non è nel PATH). Sistemalo prima di continuare.

4 — Attiva il venv (obbligatorio prima di Pillow)

Finché non attivi, i comandi pip possono finire nel Python sbagliato.

Windows — Prompt dei comandi:

.venv\Scripts\activate.bat

Windows — PowerShell:

.venv\Scripts\Activate.ps1

Se PowerShell blocca lo script con un errore di Execution Policy, esegui solo per questa finestra:

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass

Poi rilancia .venv\Scripts\Activate.ps1.

macOS / Linux:

source .venv/bin/activate

Controllo obbligatorio: all’inizio della riga del prompt deve comparire (.venv).
Esempio: (.venv) C:\Users\...\pulizia-foto> oppure (.venv) user@mac pulizia-foto %.
Se (.venv) non c’è, non installare Pillow: ripeti l’attivazione.

5 — Installa Pillow

Windows (solo con (.venv) visibile):

python -m pip install Pillow

macOS / Linux (solo con (.venv) visibile):

python3 -m pip install Pillow

Cosa deve comparire: barre di progresso e, alla fine, una riga tipo Successfully installed Pillow-10.x.x (il numero può cambiare).
Se non vedi quella conferma, fermati: qualcosa è andato storto.

6 — Verifica che Pillow sia importabile

Windows:

python -c "import PIL; print(PIL.__version__)"

macOS / Linux:

python3 -c "import PIL; print(PIL.__version__)"

Se compare un numero (es. 10.4.0), l’ambiente è pronto.
Se compare ModuleNotFoundError: No module named 'PIL': il venv non era attivo. Torna al passo 4, riattiva, ripeti i passi 5 e 6.

💡 Letture opzionali (non servono per finire questa guida): approfondimenti su terminale, venv e pip se vuoi allargare — Terminale: comandi minimi, Ambienti virtuali (venv), Quando usare pip install.

---

Passaggio 2 — Il codice sorgente

Puoi scaricare lo script verificato dalla scheda in cima alla pagina, oppure creare un file pulisci_exif.py e incollare il sorgente qui sotto (è lo stesso file).

Download: pulisci_exif.py
SHA-256: 2824b640df0d59c0942b21e0e5353331f8ab8d4f53c8c439aeda02a4727aee2d
Repository: lunoffice/rimuovere-metadati-exif-foto (MIT, release v1.0.0)

#!/usr/bin/env python3
"""
pulisci_exif.py — ai riparo (Alex Lunalbi)
Rimuove i metadati EXIF (inclusi GPS, data di scatto, modello dispositivo)
da un'immagine, salvando una copia locale senza sovrascrivere l'originale.

Non invia nulla online. Nessuna telemetria.

Licenza: MIT
Requisiti: Python 3.9+, Pillow (python -m pip install Pillow / python3 -m pip)
Versione: 1.0.0

Uso:
  python pulisci_exif.py foto.jpg
  python3 pulisci_exif.py foto.jpg
  python pulisci_exif.py "C:\\Users\\Tu\\Foto estate\\foto.jpg"
  python3 pulisci_exif.py "/Users/tu/Foto estate/foto.jpg"
"""

from __future__ import annotations

import argparse
import sys
from pathlib import Path

try:
    from PIL import Image, ImageOps
except ImportError:
    print(
        "Errore: manca la libreria Pillow.\n"
        "Attiva il venv, poi digita:\n"
        "  Windows:  python -m pip install Pillow\n"
        "  macOS/Linux: python3 -m pip install Pillow",
        file=sys.stderr,
    )
    sys.exit(1)

__version__ = "1.0.0"

SUPPORTED_SUFFIXES = {".jpg", ".jpeg", ".png", ".webp", ".tif", ".tiff"}


def rimuovi_metadati(percorso: Path) -> Path:
    """Crea una copia senza EXIF accanto all'originale (prefisso pulita_)."""
    if not percorso.is_file():
        raise FileNotFoundError(f"Il file non esiste: {percorso}")

    suffix = percorso.suffix.lower()
    if suffix not in SUPPORTED_SUFFIXES:
        raise ValueError(
            f"Formato non supportato ({suffix}). "
            f"Usa: {', '.join(sorted(SUPPORTED_SUFFIXES))}"
        )

    output = percorso.with_name(f"pulita_{percorso.name}")

    with Image.open(percorso) as immagine:
        # Applica l'orientamento EXIF ai pixel, poi scarta i metadati.
        # Evita che le foto verticali risultino "sdraiate" dopo la pulizia.
        immagine = ImageOps.exif_transpose(immagine)

        info = dict(immagine.info)
        info.pop("exif", None)
        info.pop("xmp", None)

        save_kwargs: dict = {}
        if suffix in {".jpg", ".jpeg"}:
            # JPEG non supporta la trasparenza; convertiamo se necessario.
            if immagine.mode in {"RGBA", "P"}:
                immagine = immagine.convert("RGB")
            save_kwargs["quality"] = 95
            save_kwargs["optimize"] = True

        immagine.save(output, **save_kwargs)

    return output


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        description=(
            "Rimuove i metadati EXIF da un'immagine e salva una copia "
            "con prefisso pulita_ (l'originale non viene toccato)."
        )
    )
    parser.add_argument(
        "immagine",
        type=Path,
        help="Percorso del file immagine da pulire",
    )
    parser.add_argument(
        "--version",
        action="version",
        version=f"%(prog)s {__version__}",
    )
    return parser


def main(argv: list[str] | None = None) -> int:
    parser = build_parser()
    args = parser.parse_args(argv)

    try:
        print(f"Lettura: {args.immagine}")
        output = rimuovi_metadati(args.immagine.resolve())
        print(f"Fatto. Immagine senza metadati salvata in: {output}")
        return 0
    except (FileNotFoundError, ValueError, OSError) as exc:
        print(f"Errore: {exc}", file=sys.stderr)
        return 1


if __name__ == "__main__":
    raise SystemExit(main())

ℹ️ Nota: lo script salva solo i pixel (dopo aver applicato l’orientamento). GPS, data di scatto e modello della fotocamera non finiscono nella copia pulita_....

---

Passaggio 3 — Esecuzione e lettura dei risultati

1. Scarica lo script dalla scheda in cima (oppure salva il file pulisci_exif.py creato al passaggio 2) nella stessa cartella pulizia-foto dove hai il venv.
2. Copia lì una foto di prova dello smartphone, ad esempio vacanza.jpg.
3. Controlla che il terminale sia ancora in quella cartella e che il prompt mostri (.venv). Se hai chiuso la finestra, riapri il terminale, fai di nuovo cd nella cartella e riattiva il venv (passo 4 del Passaggio 1).

Poi lancia lo script:

Windows:

python pulisci_exif.py vacanza.jpg

macOS / Linux:

python3 pulisci_exif.py vacanza.jpg

Se il percorso della foto contiene spazi, usa le virgolette:

Windows:

python pulisci_exif.py "C:\Users\Tu\Documents\pulizia-foto\Foto estate\vacanza.jpg"

macOS:

python3 pulisci_exif.py "/Users/tu/Documents/pulizia-foto/Foto estate/vacanza.jpg"

Linux:

python3 pulisci_exif.py "/home/tu/Documents/pulizia-foto/Foto estate/vacanza.jpg"

Output atteso:

Lettura: vacanza.jpg
Fatto. Immagine senza metadati salvata in: ...\pulita_vacanza.jpg

Nella cartella compare il nuovo file pulita_vacanza.jpg. L’originale non viene modificato.

La prova del nove

Per verificare che lo script abbia fatto il suo dovere, controlla i metadati del file originale e poi della copia pulita_....

Windows (percorso principale):

1. Clic destro su vacanza.jpg → Proprietà.
2. Scheda Dettagli.
3. Scorri fino a latitudine / longitudine (se presenti).

macOS:

1. Seleziona il file nel Finder.
2. File → Ottieni informazioni (oppure Cmd + I).
3. Espandi le sezioni con i dati GPS / EXIF, se disponibili.

Linux:

1. Nel file manager (Nautilus, Dolphin, Thunar, ecc.): clic destro → Proprietà / Dettagli.
2. Oppure, dal terminale (se hai exiftool o identify installati), puoi ispezionare i tag; non sono obbligatori per seguire questa guida.

Ripeti la stessa verifica su pulita_vacanza.jpg: la sezione GPS e le informazioni sulla fotocamera non dovrebbero più esserci. A quel punto la copia è più sicura da allegare a un’email o da caricare dove i metadati non vengono rimossi in automatico.

⚠️ Attenzione — Limiti onesti: lo script rimuove i metadati EXIF/XMP gestiti da Pillow al salvataggio. Non è un «sanitizer forense» completo per ogni formato container. Per l’uso quotidiano (JPEG/PNG delle foto smartphone) nei miei test è sufficiente; per casi estremi servirebbero strumenti dedicati.

---

Domande Frequenti (FAQ)

Cosa sono i metadati EXIF e perché rimuoverli prima di condividere una foto?

Sono informazioni tecniche (spesso GPS, modello del telefono, data) incorporate nel file. Se carichi lo scatto “così com’è” su un forum o lo invii per email, puoi rivelare dove e quando è stata scattata senza volerlo.

Serve internet o un sito online per pulire le foto con questo metodo?

No. Lo script gira in locale con Python e Pillow: le immagini non lasciano il computer. È il punto della guida rispetto ai “pulisci EXIF gratis” che caricano il file su server terzi.

Come preparo l’ambiente e installo Pillow su Windows, macOS e Linux?

Crea un venv, attivalo, poi: Windows python -m pip install Pillow; macOS/Linux python3 -m pip install Pillow. Verifica con python -c "from PIL import Image; print(Image.__version__)" (usa python3 su Mac/Linux).

Lo script cancella anche watermark, testo nella foto o dati “forensi” avanzati?

No. Rimuove i metadati EXIF/XMP gestiti al salvataggio da Pillow. Non è un sanitizer forense completo di ogni container. Per JPEG/PNG tipici da smartphone, nei miei test basta per l’uso quotidiano.

Come verifico che GPS e dati fotocamera siano spariti dopo la pulizia?

Su Windows: Proprietà del file → dettagli. Su macOS: Ottieni informazioni. Su Linux: proprietà nel file manager. Confronta l’originale e la copia _pulita: la sezione GPS e i campi fotocamera non dovrebbero più esserci.

C’è un repository GitHub?

Sì: lunoffice/rimuovere-metadati-exif-foto, con README, licenza MIT e release v1.0.0 che contiene pulisci_exif.py. Lo SHA-256 è lo stesso della scheda download di questa pagina.

Conclusione

Con poche righe di codice hai un tool di privacy personale. Invece di affidarti a un sito gratuito che elabora la foto sui suoi server, l’operazione resta sul tuo processore: nessun dato esce dal computer.

💡 Letture opzionali: se vuoi approfondire (non servono per usare questo script) — Quando usare pip install e quando no e Come verificare un download con SHA-256 e, per documenti invece che foto, Unire PDF in locale.