# Blober Path Templates: Organize Files During Transfer

> Learn how Blober destination paths work with source selection, folder preservation, path variables, filters, previews, copy, and move.

## What Path Templating Means in Blober

A file transfer normally answers two questions: what should move, and where should it go. Blober adds a third: **what destination path should each file receive?**

That matters because copying a disorganized source without thinking about paths creates a disorganized backup. A bucket containing `clip001.mp4`, `invoice.pdf`, `DSC_4821.ARW`, and years of nested project folders can be copied exactly as it is, filtered to a useful subset, or rearranged into a new structure while it moves.

Blober path templates are destination rules. They combine ordinary folder text with variables such as `{file_ext}`, `{file_created_date}`, and `{filename}`. Blober evaluates the template separately for every matching file and creates that file's relative destination path.

```text
media/{file_ext}/{file_created_date}/{filename}
```

For a video named `GX015742.MP4` with a reported creation date of July 18, 2026, the relative result is:

```text
media/mp4/2026-07-18/GX015742.MP4
```

If the selected destination folder is `studio-archive`, the complete destination becomes:

```text
studio-archive/media/mp4/2026-07-18/GX015742.MP4
```

No separate organizer, database, script, or integration platform is involved. The organization happens as part of the copy or move.

## Where the Feature Is in the App

Path setup spans three numbered sections in the workflow editor. For the step-by-step app reference, see the [Workflows guide](/kb/docs/desktop-app/workflows#path-templates).

### 1. Source Configuration

Choose the source provider, authenticate it, then click **Browse Files and Folders**. You can select individual files, multiple files, folders, or an entire storage root when the provider supports it.

If at least one folder is selected, **Advanced Filters (Optional)** appears. It can restrict files by:

* File extension
* Created-date range
* File-size range
* Whether subdirectories are included
* Include glob pattern
* Exclude glob pattern

Source selection defines **where Blober looks**. Filters define **which files inside that scope qualify**.

### 2. Destination Configuration

Choose the destination provider and **Select Destination Folder**. Once the destination is complete, expand **Advanced Path Template (Optional)**.

The **Template Pattern** field is appended beneath the destination folder. The variable list below the field can be clicked to add placeholders. Blober also shows an example output while the pattern is being edited.

### 3. Preview & Summary

The preview shows active filters, the destination template, source items, and expected destination paths. This is where a path rule becomes understandable before files move.

Do not treat preview as decoration. A template can deliberately flatten a hierarchy, split files into new folders, or rename every destination. Preview is the check that the rule means what you think it means.

## The Three Path Modes

### Mode 1: Copy the Structure As-Is

Leave **Advanced Path Template** empty and keep **Include Subdirectories** enabled. Blober automatically retains the relative directory structure beneath the selected folder.

Selected folder:

```text
Projects/
  Client-A/
    Final/
      film.mp4
```

Destination result:

```text
Client-A/Final/film.mp4
```

This is the right mode for a faithful backup. You do not need a template merely because templates exist.

### Mode 2: Flatten the Selection

Leave the template empty and disable **Include Subdirectories**. Files are placed by filename without their relative source folders.

This can be useful when collecting documents into one destination, but duplicate filenames from different source folders may target the same destination name. Preview the result carefully.

### Mode 3: Build a Custom Path

Enter a path template. The template takes control of the relative destination path. Automatic subdirectory preservation no longer adds the source hierarchy behind the scenes.

That rule is easy to miss:

```text
{file_created_date}/{filename}
```

organizes by date but does **not** preserve source subfolders.

To retain relative source folders inside a custom path, explicitly include `{file_dir}`:

```text
{file_created_date}/{file_dir}/{filename}
```

Read the dedicated [`{file_dir}` guide](/kb/articles/blober-file-dir-path-template/) before relying on it. Its value depends on whether a file or folder was selected and how deeply the file sits beneath that selected folder.

## Every Available Variable

| Variable                   | Meaning                                        | Example               |
| -------------------------- | ---------------------------------------------- | --------------------- |
| `{current_date}`           | Current processing date                        | `2026-07-20`          |
| `{current_datetime}`       | Current processing date and time               | `2026-07-20_14-30-00` |
| `{file_created_date}`      | Source-reported creation date                  | `2026-07-18`          |
| `{file_created_datetime}`  | Source-reported creation date and time         | `2026-07-18_09-15-30` |
| `{file_modified_date}`     | Source-reported modification date              | `2026-07-19`          |
| `{file_modified_datetime}` | Source-reported modification date and time     | `2026-07-19_16-45-22` |
| `{file_accessed_date}`     | Source-reported access date                    | `2026-07-20`          |
| `{file_accessed_datetime}` | Source-reported access date and time           | `2026-07-20_12-00-15` |
| `{filename}`               | Complete filename                              | `GX015742.MP4`        |
| `{filename_no_ext}`        | Filename without extension                     | `GX015742`            |
| `{file_ext}`               | Extension without the dot                      | `mp4`                 |
| `{file_size}`              | Exact size in bytes                            | `1572864`             |
| `{file_size_mb}`           | Exact size in MB, rounded to two decimals      | `1.50`                |
| `{file_dir}`               | Relative directory beneath the selected folder | `Day-2/Camera-A`      |

These are deterministic metadata substitutions, not AI classifications. Blober does not inspect an image and infer a client, location, or subject. If `Client-A` is not present in a selected path, filename, or available variable, a template cannot invent it.

## How Template Evaluation Works

Suppose the destination folder is:

```text
Archive
```

The selected source folder is:

```text
Shoots
```

and one matching file is:

```text
Shoots/Wedding-2026/Camera-A/DSC_4821.ARW
```

For that file:

```text
{file_dir} = Wedding-2026/Camera-A
{filename} = DSC_4821.ARW
{filename_no_ext} = DSC_4821
{file_ext} = arw
```

This template:

```text
originals/{file_dir}/{filename}
```

produces:

```text
Archive/originals/Wedding-2026/Camera-A/DSC_4821.ARW
```

This template:

```text
by-type/{file_ext}/{filename}
```

produces:

```text
Archive/by-type/arw/DSC_4821.ARW
```

The second rule intentionally discards the source folder hierarchy because it does not contain `{file_dir}`.

## Variables and Filters Solve Different Problems

Filters decide whether a file participates. Variables decide where a participating file lands.

For example:

```text
Include pattern: **/*.{jpg,png}
Exclude pattern: **/thumbnails/**
Template: images/{file_created_date}/{filename}
```

The include pattern rejects non-image extensions. The exclude pattern removes thumbnails. The path template organizes the remaining files by creation date.

Keeping those concepts separate makes workflows easier to reason about:

1. Select a source boundary.
2. Filter the files inside it.
3. Build the destination path for each match.
4. Preview.
5. Copy or move.

## Important Metadata Limits

Path templates use metadata supplied by the source provider or filesystem. Not every backend describes dates and sizes in exactly the same way.

* A cloud object may expose upload or modification time rather than the camera's original capture time.
* Access time may be unavailable or unhelpful on object storage.
* Unknown file size becomes `NO_SIZE` or `NO_SIZE_MB` when used in a template.
* `{file_size_mb}` creates an exact numeric folder such as `142.53`; it does not automatically create human categories such as `small` or `large`.
* File extensions come from filenames. A misleading extension is not content inspection.

These limits do not make templates unreliable. They define what the rule can truthfully know. Use preview to inspect real metadata from the selected source.

## Copy and Move

Use **Copy** when:

* Creating a backup
* Testing a new destination structure
* Building a second organized library
* Keeping the source as the working location

Use **Move** when:

* The destination has been verified
* The source should be cleaned up
* Files are being retired from expensive active storage

A move deletes the source after successful transfer. For any new path rule, run a representative copy first.

Blober can also reorganize between supported locations on the same provider, but source and destination cannot overlap. Do not place a destination inside the selected source tree. Choose a separate folder, bucket, container, or account.

## Detailed Guides in This Series

* [How `{file_dir}` Really Works](/kb/articles/blober-file-dir-path-template/)
* [File Selection and Glob Include/Exclude Filters](/kb/articles/blober-file-selection-glob-filters/)
* [Organize Files by Created, Modified, Accessed, or Current Date](/kb/articles/organize-files-by-date-path-templates/)
* [Organize Files by Type and Extension](/kb/articles/organize-files-by-type-extension/)
* [Filter and Organize Files by Size](/kb/articles/organize-files-by-size/)
* [Organize Blob Storage Without Advanced Search](/kb/articles/organize-blob-storage-without-search/)
* [Media and Professional File-Organization Workflows](/kb/articles/media-file-organization-workflows/)
* [Copy As-Is, Organize During Backup, or Reorganize With Move](/kb/articles/copy-move-organize-files-during-transfer/)

## A Safe First Workflow

1. Create a new workflow and choose **Copy**.
2. Select one folder containing several levels, file types, and sizes.
3. Choose a separate destination folder.
4. Enter `{file_ext}/{file_dir}/{filename}`.
5. Inspect every example in **Preview & Summary**.
6. Save and run the workflow.
7. Verify the actual destination before scaling up.

That small test reveals exactly how the source provider reports dates, extensions, sizes, and relative folders. Once the output is correct, the same saved workflow can handle a much larger selection.

**[Download Blober at blober.io](https://blober.io)** to organize files as they move between cloud storage, object storage, local disks, and network drives.