Wissensdatenbank
1 000 FAQs, 500 Anleitungen und erläuternde Videos. Hier gibt es nur Lösungen!
Google-Fotos in kDrive importieren
Diese Anleitung erklärt, wie Sie Ihre Fotos von Google Fotos (https://photos.google.com/) exportieren und anschließend in kDrive von Infomaniak importieren.
Einleitung
- Weitere verfügbare Importanleitungen:
1. Ihre Google-Fotos exportieren
Um die in Google Fotos gespeicherten Fotos auf Ihrem Computer herunterzuladen, verwenden Sie Google Takeout. Mit diesem Dienst können Sie entweder alle Elemente exportieren oder nur bestimmte Alben auswählen, wenn Sie dies schrittweise vornehmen möchten:
- Melden Sie sich bei Google Takeout an.
- Deaktivieren Sie alle Produkte, um nur Google Fotos beizubehalten:

- Wählen Sie gegebenenfalls die Alben aus, die nicht exportiert werden sollen:

- Gehen Sie zum nächsten Schritt am unteren Rand der Seite:

- Konfigurieren Sie den Export im ZIP-Format.
- Klicken Sie auf die Schaltfläche Export erstellen, um den Export zu starten:

- Warten Sie, bis Sie die E-Mail mit den Download-Links erhalten. Je nach Datenmenge kann die Erstellung des Exports mehrere Stunden oder sogar Tage dauern.
- Laden Sie die ZIP-Archive herunter und entpacken Sie sie anschließend auf Ihrem Computer:

- Gruppieren Sie gegebenenfalls die exportierten Ordner, bevor Sie sie in kDrive importieren.
2. Datumsangaben der exportierten Dateien korrigieren
Beim Export können die Systemdatumsangaben der Dateien durch das Exportdatum anstelle des ursprünglichen Aufnahmedatums ersetzt werden. Wenn die chronologische Reihenfolge der Fotos nach dem Export nicht korrekt ist, können Sie diese Datumsangaben vor dem Import in kDrive korrigieren.
Bevor Sie ein Skript ausführen, arbeiten Sie mit einer Kopie Ihrer exportierten Dateien. Löschen Sie die von Google Takeout bereitgestellten .json-Dateien nicht, bevor Sie sie verarbeiten: Sie können das ursprüngliche Datum enthalten, falls dieses nicht in den EXIF-Metadaten der Datei verfügbar ist.
Die folgenden Skripte suchen in dieser Reihenfolge nach einem Datum: Metadaten der Datei, zugehörige JSON-Datei von Google Takeout und dann das im Dateinamen enthaltene Datum. Dateien, bei denen kein verwendbares Datum gefunden wurde, werden in einer Datei DateError.txt auf dem Desktop aufgelistet. Die korrigierten Dateien werden in DateFound.txt aufgelistet.
Um das Risiko von Blockaden bei sehr großen Exporten zu minimieren, verarbeiten Sie die Dateien in Batches von einigen Tausend Elementen.
Datumsangaben unter macOS korrigieren
- Laden Sie ExifTool herunter und installieren Sie es von https://exiftool.org/index.html, indem Sie das macOS-Paket auswählen.
- Öffnen Sie die Anwendung Terminal im Ordner Programme > Dienstprogramme.
- Kopieren Sie den folgenden Codeblock vollständig in das Terminal und bestätigen Sie ihn gegebenenfalls mit der Eingabetaste.
- Wählen Sie den Ordner aus, der die von Google Takeout exportierten Dateien enthält.
- Warten Sie, bis die Verarbeitung abgeschlossen ist, und überprüfen Sie dann die auf dem Desktop erstellten Dateien
DateFound.txtundDateError.txt.
Das folgende Skript muss vollständig kopiert und eingefügt werden:
/bin/bash <<'BASH'
#!/bin/bash
set -u
ROOT="$(osascript -e 'POSIX path of (choose folder with prompt "Select the folder containing the files to update")')" || exit 0
DESKTOP="$HOME/Desktop"
LOG_FOUND="$DESKTOP/DateFound.txt"
LOG_ERROR="$DESKTOP/DateError.txt"
: > "$LOG_FOUND"
: > "$LOG_ERROR"
find_exiftool() {
if command -v exiftool >/dev/null 2>&1; then
command -v exiftool
return 0
fi
if [ -x "/usr/local/bin/exiftool" ]; then
printf '%s\n' "/usr/local/bin/exiftool"
return 0
fi
if [ -x "/opt/homebrew/bin/exiftool" ]; then
printf '%s\n' "/opt/homebrew/bin/exiftool"
return 0
fi
return 1
}
EXIFTOOL="$(find_exiftool)" || {
printf '%s\n' "ExifTool not found. Install it, then run the script again." >> "$LOG_ERROR"
printf '%s\n' "ExifTool not found. Check DateError.txt on the desktop."
exit 1
}
if [ ! -d "$ROOT" ]; then
printf 'Invalid folder: %s\n' "$ROOT" >> "$LOG_ERROR"
printf '%s\n' "Invalid folder. Check DateError.txt on the desktop."
exit 1
fi
get_exif_date() {
"$EXIFTOOL" -s3 -d "%Y:%m:%d %H:%M:%S" -DateTimeOriginal -CreateDate -MediaCreateDate -TrackCreateDate -CreationDate -ModifyDate -- "$1" 2>/dev/null | awk '/^[0-9]{4}:[0-9]{2}:[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}/ { print substr($0, 1, 19); exit }'
}
get_json_date() {
local file="$1"
local json=""
if [ -f "$file.json" ]; then
json="$file.json"
elif [ -f "${file%.*}.json" ]; then
json="${file%.*}.json"
fi
[ -z "$json" ] && return 1
/usr/bin/perl -MTime::Piece -0777 -ne 'if (/"photoTakenTime"\s*:\s*\{.*?"timestamp"\s*:\s*"([0-9]+)"/s || /"creationTime"\s*:\s*\{.*?"timestamp"\s*:\s*"([0-9]+)"/s) { print localtime($1)->strftime("%Y:%m:%d %H:%M:%S"); }' "$json"
}
get_name_date() {
local name
name="$(basename "$1")"
if [[ "$name" =~ ([12][0-9]{3})[-_]?([01][0-9])[-_]?([0-3][0-9])([_\ -]?([0-2][0-9])[-_\.]?([0-5][0-9])[-_\.]?([0-5][0-9]))? ]]; then
local year="${BASH_REMATCH[1]}"
local month="${BASH_REMATCH[2]}"
local day="${BASH_REMATCH[3]}"
local hour="12"
local minute="00"
local second="00"
if [ -n "${BASH_REMATCH[5]:-}" ]; then
hour="${BASH_REMATCH[5]}"
minute="${BASH_REMATCH[6]}"
second="${BASH_REMATCH[7]}"
fi
printf '%s:%s:%s %s:%s:%s\n' "$year" "$month" "$day" "$hour" "$minute" "$second"
return 0
fi
return 1
}
is_valid_date() {
date -j -f "%Y:%m:%d %H:%M:%S" "$1" "+%Y:%m:%d %H:%M:%S" >/dev/null 2>&1
}
to_touch_date() {
printf '%s' "$1" | sed -E 's/^([0-9]{4}):([0-9]{2}):([0-9]{2}) ([0-9]{2}):([0-9]{2}):([0-9]{2})$/\1\2\3\4\5.\6/'
}
write_metadata() {
local file="$1"
local date_value="$2"
"$EXIFTOOL" -overwrite_original "-DateTimeOriginal=$date_value" "-CreateDate=$date_value" "-ModifyDate=$date_value" -- "$file" >/dev/null 2>&1 || true
}
process_file() {
local file="$1"
local date_value=""
local source=""
date_value="$(get_exif_date "$file")"
if [ -n "$date_value" ]; then
source="EXIF"
else
date_value="$(get_json_date "$file")"
if [ -n "$date_value" ]; then
source="Google Takeout JSON"
else
date_value="$(get_name_date "$file")"
if [ -n "$date_value" ]; then
source="file name"
fi
fi
fi
if [ -n "$date_value" ] && is_valid_date "$date_value"; then
local touch_value
touch_value="$(to_touch_date "$date_value")"
if [ "$source" != "EXIF" ]; then
write_metadata "$file" "$date_value"
fi
if touch -t "$touch_value" "$file" 2>/dev/null; then
printf '%s | %s | %s\n' "$source" "$date_value" "$file" >> "$LOG_FOUND"
else
printf 'Unable to update file date: %s\n' "$file" >> "$LOG_ERROR"
fi
else
printf 'No valid date found: %s\n' "$file" >> "$LOG_ERROR"
fi
}
while IFS= read -r -d '' file; do
case "$file" in
*.json|*_original) continue ;;
esac
process_file "$file"
done < <(find "$ROOT" -type f -print0)
printf '%s\n' "Done. Check DateFound.txt and DateError.txt on the desktop."
BASH
Datumsangaben unter Windows korrigieren
- Laden Sie ExifTool von https://exiftool.org/index.html herunter, indem Sie die Windows-Version auswählen.
- Legen Sie die Datei in einem zugänglichen Ordner ab, z. B.
C:\ExifTool. - Benennen Sie die Datei
exiftool(-k).exeinexiftool.exeum. - Vergewissern Sie sich, dass der vollständige Pfad korrekt ist:
C:\ExifTool\exiftool.exe.- Wenn Sie ExifTool an einem anderen Ort speichern, ändern Sie die erste Zeile der Konfiguration im folgenden Skript.
- Kopieren Sie das folgende Skript und fügen Sie es in den Editor ein.
- Speichern Sie die Datei mit der Erweiterung
.ps1, zum BeispielUpdateExifDates.ps1. - Klicken Sie mit der rechten Maustaste auf die Datei
.ps1und führen Sie sie mit PowerShell aus. - Wählen Sie den Ordner aus, der die von Google Takeout exportierten Dateien enthält.
- Warten Sie, bis die Verarbeitung abgeschlossen ist, und überprüfen Sie dann die auf dem Desktop erstellten Dateien
DateFound.txtundDateError.txt.
Wenn PowerShell die Ausführung des Skripts blockiert, öffnen Sie PowerShell und führen Sie den Befehl Set-ExecutionPolicy RemoteSigned -Scope CurrentUser aus. Bestätigen Sie anschließend die Änderung, wenn Windows Sie dazu auffordert.
Das folgende Skript muss vollständig kopiert und eingefügt werden:
# === Configuration ===
$ExifToolPath = "C:\ExifTool\exiftool.exe"
$Desktop = [Environment]::GetFolderPath("Desktop")
$LogFound = Join-Path $Desktop "DateFound.txt"
$LogError = Join-Path $Desktop "DateError.txt"
Set-Content -Path $LogFound -Value ""
Set-Content -Path $LogError -Value ""
if (-not (Test-Path -LiteralPath $ExifToolPath)) {
Add-Content -Path $LogError -Value "ExifTool not found: $ExifToolPath"
Write-Host "ExifTool not found. Check the path in the script."
exit
}
# === Folder selection dialog ===
Add-Type -AssemblyName System.Windows.Forms
$FolderBrowser = New-Object System.Windows.Forms.FolderBrowserDialog
$FolderBrowser.Description = "Select the folder to process"
if ($FolderBrowser.ShowDialog() -ne [System.Windows.Forms.DialogResult]::OK) { exit }
$Folder = $FolderBrowser.SelectedPath
function Get-DateFromExif {
param ([string]$FilePath)
$Tags = @("DateTimeOriginal", "CreateDate", "MediaCreateDate", "TrackCreateDate", "CreationDate", "ModifyDate")
foreach ($Tag in $Tags) {
$Value = (& $ExifToolPath "-$Tag" -s3 -d "%Y:%m:%d %H:%M:%S" -- "$FilePath" 2>$null | Select-Object -First 1)
if ($Value -match '^(\d{4}):(\d{2}):(\d{2}) (\d{2}):(\d{2}):(\d{2})') {
try {
return [datetime]::ParseExact($Matches[0], "yyyy:MM:dd HH:mm:ss", [Globalization.CultureInfo]::InvariantCulture)
} catch {}
}
}
return $null
}
function Get-DateFromJson {
param ([string]$FilePath)
$JsonPaths = @("$FilePath.json", [System.IO.Path]::ChangeExtension($FilePath, ".json")) | Select-Object -Unique
foreach ($JsonPath in $JsonPaths) {
if (Test-Path -LiteralPath $JsonPath) {
try {
$Json = Get-Content -LiteralPath $JsonPath -Raw -ErrorAction Stop | ConvertFrom-Json -ErrorAction Stop
$Timestamp = $null
if ($Json.photoTakenTime -and $Json.photoTakenTime.timestamp) {
$Timestamp = [int64]$Json.photoTakenTime.timestamp
} elseif ($Json.creationTime -and $Json.creationTime.timestamp) {
$Timestamp = [int64]$Json.creationTime.timestamp
}
if ($null -ne $Timestamp) {
return ([DateTimeOffset]::FromUnixTimeSeconds($Timestamp)).LocalDateTime
}
} catch {}
}
}
return $null
}
function Get-DateFromFileName {
param ([string]$FileName)
if ($FileName -match '([12]\d{3})[-_]?(0[1-9]|1[0-2])[-_]?(0[1-9]|[12]\d|3[01])(?:[ _-]?([01]\d|2[0-3])[-_.]?([0-5]\d)[-_.]?([0-5]\d))?') {
$Year = $Matches[1]
$Month = $Matches[2]
$Day = $Matches[3]
$Hour = "12"
$Minute = "00"
$Second = "00"
if ($Matches[4]) {
$Hour = $Matches[4]
$Minute = $Matches[5]
$Second = $Matches[6]
}
$DateString = "$Year$Month$Day$Hour$Minute$Second"
try {
return [datetime]::ParseExact($DateString, "yyyyMMddHHmmss", [Globalization.CultureInfo]::InvariantCulture)
} catch {}
}
return $null
}
function Write-Metadata {
param (
[string]$FilePath,
[datetime]$DateValue
)
$ExifDate = $DateValue.ToString("yyyy:MM:dd HH:mm:ss", [Globalization.CultureInfo]::InvariantCulture)
& $ExifToolPath -overwrite_original "-DateTimeOriginal=$ExifDate" "-CreateDate=$ExifDate" "-ModifyDate=$ExifDate" -- "$FilePath" 2>$null | Out-Null
}
function Set-FileDates {
param (
[string]$FilePath,
[datetime]$DateValue
)
[System.IO.File]::SetCreationTime($FilePath, $DateValue)
[System.IO.File]::SetLastWriteTime($FilePath, $DateValue)
[System.IO.File]::SetLastAccessTime($FilePath, $DateValue)
}
Get-ChildItem -LiteralPath $Folder -Recurse -File | Where-Object {
$_.Extension -ne ".json" -and $_.Name -notlike "*_original"
} | ForEach-Object {
$File = $_
$FilePath = $File.FullName
$DateValue = Get-DateFromExif -FilePath $FilePath
$Source = "EXIF"
if (-not $DateValue) {
$DateValue = Get-DateFromJson -FilePath $FilePath
$Source = "Google Takeout JSON"
}
if (-not $DateValue) {
$DateValue = Get-DateFromFileName -FileName $File.Name
$Source = "file name"
}
if ($DateValue) {
try {
if ($Source -ne "EXIF") {
Write-Metadata -FilePath $FilePath -DateValue $DateValue
}
Set-FileDates -FilePath $FilePath -DateValue $DateValue
Add-Content -Path $LogFound -Value "$Source | $($DateValue.ToString('yyyy-MM-dd HH:mm:ss')) | $FilePath"
} catch {
Add-Content -Path $LogError -Value "Unable to update file date: $FilePath"
}
} else {
Add-Content -Path $LogError -Value "No valid date found: $FilePath"
}
}
[System.Windows.Forms.MessageBox]::Show("Done. Check DateFound.txt and DateError.txt on the desktop.")
3. Fotos in kDrive importieren
Ändern Sie Ihre Passwörter nicht, bevor der Import oder die Synchronisierung abgeschlossen ist.
Sobald Ihre Dateien bereit sind, können Sie diese über die Web-App kDrive hochladen, sofern die Anzahl der Dateien und Ihre Internetverbindung dies zulassen:
- Öffnen Sie die Web-App kDrive von Infomaniak.
- Öffnen Sie den Ordner, in den die Fotos importiert werden sollen.
- Klicken Sie auf die Schaltfläche Neu oben links.
- Klicken Sie auf Ordner importieren.
- Wählen Sie den Ordner mit Ihren Fotos auf Ihrem Computer aus.
- Warten Sie, bis der Import abgeschlossen ist. Das Aktivitätsprotokoll wird unten rechts angezeigt:

Wenn Sie die Desktop-App kDrive verwenden, können Sie den Ordner mit Ihren Fotos auch in der Ordnerstruktur Ihres kDrive-Ordners auf dem Computer platzieren. Die Synchronisierung startet dann automatisch, und die Dateien werden auf die Infomaniak-Server übertragen.
4. Zugriff auf Fotos von Ihren Geräten aus
Sobald der Import oder die Synchronisierung abgeschlossen ist, können Sie von Ihren mit Ihrem kDrive verbundenen Geräten auf Ihre Fotos zugreifen.
- In der Web-App kDrive können Sie die Anzeige anpassen, um die Miniaturansichten zu vergrößern und Ihre Fotos einfacher zu durchsuchen:

Link zu dieser FAQ: https://faq.infomaniak.com/2540
War diese FAQ nützlich?