Column Name	Type	Computed With
source_image	Image

source_image_fileurl
https://raw.githubusercontent.com/pixeltable/pixeltable/main/docs/resources/images/000000000036.jpg

flipped	flipped_fileurl
	file:///Users/alison-pxt/.pixeltable/media/1dd39d15ce9f4c65ab8ccddc0e4d52ed/19/19fb/1dd39d15ce9f4c65ab8ccddc0e4d52ed_3_2_19fba58d492a44949ddba1dda374dd44.jpeg

rotated	rotated_fileurl
	file:///Users/alison-pxt/Desktop/pixeltable_outputs/rotated/1dd39d15ce9f4c65ab8ccddc0e4d52ed/dd/dd16/1dd39d15ce9f4c65ab8ccddc0e4d52ed_4_3_dd161a29915e43d691be8ee98cbda232.jpeg

flipped	flipped_fileurl
	file:///Users/alison-pxt/.pixeltable/media/1dd39d15ce9f4c65ab8ccddc0e4d52ed/19/19fb/1dd39d15ce9f4c65ab8ccddc0e4d52ed_3_2_19fba58d492a44949ddba1dda374dd44.jpeg

Provider	URI Format	Example
Amazon S3	`s3://bucket-name/prefix/`	`s3://my-bucket/media/`
Google Cloud Storage	`gs://bucket-name/prefix/`	`gs://my-gcs-bucket/media/`
Azure Blob Storage	`wasbs://container@account.blob.core.windows.net/prefix/`	`wasbs://media@myaccount.blob.core.windows.net/files/`
Cloudflare R2	`https://account-id.r2.cloudflarestorage.com/bucket-name/prefix/`	`https://abc123.r2.cloudflarestorage.com/media/files/`
Backblaze B2	`https://s3.region.backblazeb2.com/bucket-name/prefix/`	`https://s3.us-west-004.backblazeb2.com/media/files/`
Tigris	`https://fly.storage.tigris.dev/bucket-name/prefix/`	`https://fly.storage.tigris.dev/media/files/`

thumbnail	thumbnail_fileurl
	file:///Users/alison-pxt/Desktop/pixeltable_outputs/thumbnails/1dd39d15ce9f4c65ab8ccddc0e4d52ed/5f/5fc9/1dd39d15ce9f4c65ab8ccddc0e4d52ed_5_4_5fc9d0b55f2f43afbf7d4b492358393f.jpeg

source	rotated	flipped
https://raw.githubusercontent.com/pixeltable/pixeltable/main/docs/resources/images/000000000036.jpg	file:///Users/alison-pxt/Desktop/pixeltable_outputs/rotated/1dd39d15ce9f4c65ab8ccddc0e4d52ed/dd/dd16/1dd39d15ce9f4c65ab8ccddc0e4d52ed_4_3_dd161a29915e43d691be8ee98cbda232.jpeg	file:///Users/alison-pxt/.pixeltable/media/1dd39d15ce9f4c65ab8ccddc0e4d52ed/19/19fb/1dd39d15ce9f4c65ab8ccddc0e4d52ed_3_2_19fba58d492a44949ddba1dda374dd44.jpeg

cloud_thumbnail	storage_url	presigned_url
	https://s3.us-west-004.backblazeb2.com/pxt-b2/presigned-demo/28c063fafc7a4ab29bbd8f9df4547e63/3e/3eb2/28c063fafc7a4ab29bbd8f9df4547e63_6_5_3eb25d491b244110a414909626a05c45.jpeg	https://s3.us-west-004.backblazeb2.com/pxt-b2/presigned-demo/28c063fafc7a4ab29bbd8f9df4547e63/3e/3eb2/28c063fafc7a4ab29bbd8f9df4547e63_6_5_3eb25d491b244110a414909626a05c45.jpeg?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=004f2d8683c9e450000000007%2F20260115%2Fauto%2Fs3%2Faws4_request&X-Amz-Date=20260115T235533Z&X-Amz-Expires=3600&X-Amz-SignedHeaders=host&X-Amz-Signature=6e58c2b2bf698e91d3ce1957e7f6ffd53f805d3edec6d362d2193b0bac484141

Use case	Seconds	Example
Quick preview	300	5 minutes
API response	3600	1 hour
Download link	86400	24 hours
Long-term share	604800	7 days

Configuration	Local File (`/path/to/image.jpg`)	URL (`https://example.com/image.jpg`)
No `input_media_dest`	Stores path reference. File stays in place (no copying, no caching needed).	Stores URL reference. Downloads to cache when accessed (lazy).
Local `input_media_dest`	Copies file to destination.	Stores URL reference. Downloads to cache when accessed (lazy).
Cloud `input_media_dest`	Uploads to destination, caches locally.	Downloads immediately on insert, uploads to destination, caches locally.

Let’s insert a single sample image. ```python theme={null} sample_image = 'https://raw.githubusercontent.com/pixeltable/pixeltable/main/docs/resources/images/000000000036.jpg' t.insert(source_image=sample_image) ```

  Inserted 1 row with 0 errors in 0.77 s (1.29 rows/s)
  1 row inserted.

And we can see the image in our table: ```python theme={null} t.collect() ```

## Default destinations By default, Pixeltable stores all media files in local storage under `~/.pixeltable/media`: * **Input files** (files you insert) — If you insert a URL, Pixeltable stores the URL and downloads it to cache on access. If you insert a local file path, Pixeltable just stores the path reference (the file stays where it is). * **Output files** (files Pixeltable generates) — Stored in `~/.pixeltable/media` This works out of the box with no configuration. You can change these defaults, which we’ll cover in the rest of this notebook. Let’s check where the source image is stored. Since we inserted a URL (not a local file), Pixeltable stores the URL reference and will download it to cache when we access it. ```python theme={null} # Let's see where the source_image is stored by default t.select(t.source_image.fileurl).collect() ```

Now let’s add a computed column without specifying a destination. This will show us where Pixeltable stores **output** files by default. ```python theme={null} # Add computed column with no destination specified - uses default t.add_computed_column( flipped=t.source_image.transpose(0), if_exists='replace' ) ```

  Added 1 column value with 0 errors in 0.02 s (45.44 rows/s)
  1 row updated.

Check the file URL - it points to `~/.pixeltable/media`, the default location for generated files. ```python theme={null} t.select(t.flipped, t.flipped.fileurl).collect() ```

## Per-column destinations When you create a computed column, you can specify exactly where to store generated files using the `destination=` parameter. This gives you fine-grained control over outputs, which may be costly and/or difficult to re-generate. We’ll create a destination directory for storing one of our processed images. For this demo, we’re using a local directory on your Desktop, but you can replace this path with a cloud storage URI (like `s3://my-bucket/rotated/`). ```python theme={null} # Create a local destination directory # For S3: dest_rotated = "s3://my-bucket/rotated/" # For GCS: dest_rotated = "gs://my-bucket/rotated/" base_path = Path.home() / 'Desktop' / 'pixeltable_outputs' base_path.mkdir(parents=True, exist_ok=True) dest_rotated = str(base_path / 'rotated') # Create directory (only needed for local paths) Path(dest_rotated).mkdir(exist_ok=True) ``` Now let’s add a computed column **with** an explicit destination to see the difference from the default behavior. ```python theme={null} # Add column WITH explicit destination t.add_computed_column( rotated=t.source_image.rotate(90), destination=dest_rotated, if_exists='replace', ) ```

  Added 1 column value with 0 errors in 0.02 s (48.98 rows/s)
  1 row updated.

Compare the file URLs. The `rotated` image uses our explicit destination, while `flipped` (created earlier) uses the default `~/.pixeltable/media` location. ```python theme={null} t.select(t.rotated, t.rotated.fileurl).collect() ```

```python theme={null} t.select(t.flipped, t.flipped.fileurl).collect() ```

## Changing global destinations Instead of setting `destination=` on every column, you can change the global default for ALL columns. ### Output and input destinations You can configure two types of global destinations: * **`output_media_dest`** — Changes the default for files Pixeltable generates (computed columns) * **`input_media_dest`** — Changes the default for files you insert into tables You can set them to the same bucket or different buckets depending on your needs. ### How to configure You have two options: **Option 1: Configuration file** (`~/.pixeltable/config.toml`) ```toml theme={null} [pixeltable] # Where files Pixeltable generates are stored output_media_dest = "s3://my-bucket/output/" # Where files you insert are stored input_media_dest = "s3://my-bucket/input/" ``` **Option 2: Environment variables** ```bash theme={null} export PIXELTABLE_OUTPUT_MEDIA_DEST="s3://my-bucket/output/" export PIXELTABLE_INPUT_MEDIA_DEST="s3://my-bucket/input/" ``` ### Supported providers and URI formats

For complete authentication and setup details, see the [Cloud Storage documentation](/integrations/cloud-storage). ## Overriding global destinations Even if you configure global destinations, you can still override them for specific columns using the `destination=` parameter in `add_computed_column()`. Let’s create a new destination directory and add a thumbnail column that uses it. ```python theme={null} # Create a different destination for thumbnails dest_thumbnails = str(base_path / 'thumbnails') Path(dest_thumbnails).mkdir(exist_ok=True) # Add column with explicit destination (overrides any global default) t.add_computed_column( thumbnail=t.source_image.thumbnail((128, 128)), destination=dest_thumbnails, if_exists='replace', ) ```

  Added 1 column value with 0 errors in 0.02 s (47.89 rows/s)
  1 row updated.

Let’s view the thumbnail and its file URL. The explicit `destination=` parameter always wins, regardless of global configuration. ```python theme={null} t.select(t.thumbnail, t.thumbnail.fileurl).collect() ```

## Getting URLs for your files When your files are in blob storage, you can get URLs that point directly to them. These URLs work in HTML, APIs, or any application you need to serve media with. The `.fileurl` property gives you direct URLs you can use anywhere. ```python theme={null} t.select( source=t.source_image.fileurl, rotated=t.rotated.fileurl, flipped=t.flipped.fileurl, ).collect() ```

## Generating presigned URLs **Note:** This section only applies if you’re using cloud storage (S3, GCS, Azure, R2, B2, Tigris). If you’re following along with local destinations (as in the examples above), you can skip this section or configure cloud storage to try it out.

When your files are in cloud storage, the `.fileurl` property returns storage URIs like `s3://bucket/path/file.jpg`. These aren’t directly accessible over HTTP. For private buckets or when you need time-limited HTTP access, use **presigned URLs**. These are temporary, authenticated URLs that allow anyone to access your files for a limited time without needing credentials. Presigned URLs are particularly useful for: * Sharing files from private buckets without making them public * Creating temporary download links with expiration * Serving media in web applications without exposing credentials * Providing time-limited access to sensitive content Use the `presigned_url` function from `pixeltable.functions.net`: ```python theme={null} import os # Use HTTPS URL format for Backblaze B2 b2_region = 'us-east-005' b2_bucket = 'pixeltable' cloud_destination = ( f'https://s3.{b2_region}.backblazeb2.com/{b2_bucket}/presigned-demo/' ) # Add the computed column t.add_computed_column( cloud_thumbnail=t.source_image.thumbnail((64, 64)), destination=cloud_destination, if_exists='replace', ) ```

  Added 1 column value with 0 errors in 0.22 s (4.46 rows/s)
  1 row updated.

```python theme={null} # Now generate presigned URLs for the cloud-stored files from pixeltable.functions import net t.select( cloud_thumbnail=t.cloud_thumbnail, storage_url=t.cloud_thumbnail.fileurl, presigned_url=net.presigned_url( t.cloud_thumbnail.fileurl, 3600 ), # 1-hour expiration ).collect() ```

The presigned URLs in the output are fully authenticated HTTP/HTTPS URLs that can be accessed directly in a browser or used in APIs without any credentials. ### Common expiration times

**Note:** Different storage providers have different maximum expiration limits. For example, Google Cloud Storage has a maximum 7-day expiration for presigned URLs. ### Troubleshooting presigned URLs If `presigned_url()` isn’t working: 1. **Local files**: Presigned URLs only work with cloud storage (S3, GCS, Azure, R2, B2, Tigris). If your files are stored locally (default), you’ll get an error. Configure a cloud destination first. 2. **Already HTTP URLs**: If `.fileurl` returns an `http://` or `https://` URL (not a storage URI like `s3://`), the file is already publicly accessible and doesn’t need a presigned URL. 3. **Credentials**: Ensure your cloud storage credentials are properly configured. See the [Cloud Storage documentation](/integrations/cloud-storage) for provider-specific setup. ## Common patterns Here are a few real-world patterns you might use: ### Pattern 1: All media in one place If you want everything in the same bucket, configure both input and output destinations in `~/.pixeltable/config.toml`: ```toml theme={null} [pixeltable] input_media_dest = "s3://my-bucket/media/" output_media_dest = "s3://my-bucket/media/" ``` Or set environment variables: ```bash theme={null} export PIXELTABLE_INPUT_MEDIA_DEST="s3://my-bucket/media/" export PIXELTABLE_OUTPUT_MEDIA_DEST="s3://my-bucket/media/" ``` ### Pattern 2: Separate input and output Keep source files separate from processed files in `~/.pixeltable/config.toml`: ```toml theme={null} [pixeltable] input_media_dest = "s3://my-bucket/uploads/" output_media_dest = "s3://my-bucket/processed/" ``` ### Pattern 3: Override for specific columns Use a global default, but send some columns elsewhere. First, set a global default in your config: ```toml theme={null} [pixeltable] output_media_dest = "s3://my-bucket/processed/" ``` Then in your code, most columns use the global default, but you can override specific ones: ```python theme={null} # Uses global default (s3://my-bucket/processed/) t.add_computed_column( thumbnail=t.image.thumbnail((128, 128)) ) # Overrides global default - goes to different location t.add_computed_column( large_thumbnail=t.image.thumbnail((512, 512)), destination='s3://my-bucket/thumbnails/' ) ``` ## Where do my files go? Understanding how Pixeltable handles different types of input files helps you make better decisions about storage configuration.

When you configure a cloud destination, Pixeltable populates both the destination and the local cache efficiently during `insert()`. For URLs, this means downloading once and using that download for both the upload and cache—avoiding wasteful upload→download cycles. ## What you learned * Pixeltable uses local storage by default for all media files * You can override the default for specific columns with the `destination` parameter * You can change the global default with `input_media_dest` and `output_media_dest` * Precedence: column destination > global config > Pixeltable’s default local storage * Use `.fileurl` to get URLs for your stored files * Use `net.presigned_url()` to generate time-limited, authenticated HTTP URLs for cloud storage files * Pixeltable handles caching intelligently to avoid wasteful operations ## See also * [Load from S3](../../../howto/cookbooks/data/data-import-s3) - Import media from cloud storage * [Cloud Storage Integration](../../../integrations/cloud-storage) - Provider setup ## Next steps * See the [Cloud Storage documentation](/integrations/cloud-storage) for complete provider setup and authentication details * Check out [Pixeltable Configuration](/platform/configuration) for all config options * Join our [Discord community](https://pixeltable.com/discord) if you have questions Built with [Mintlify](https://mintlify.com).