# Import files from Supabase Storage

Robot: `/supabase/import`

🤖/supabase/import imports whole directories of files from your Supabase Storage bucket.

The URL to the result file will be returned in the <dfn>Assembly Status JSON</dfn>.

> [!WARNING]
> **Keep your credentials safe**
>
> Since you need to provide credentials to this Robot, always use this together with Templates and/or Template Credentials, so that you can never leak any secrets while transmitting your Assembly Instructions.

> [!NOTE]
> Transloadit supports file sizes up to 200 GB. If you require a higher limit for your application, [get in touch](mailto:hello@transloadit.com?subject=Large%20filesizes).

Stage: ga

## Usage example

Import files from the `path/to/files` directory and its subdirectories:

```json
{
  "steps": {
    "imported": {
      "credentials": "YOUR_SUPABASE_CREDENTIALS",
      "path": "path/to/files/",
      "recursive": true,
      "robot": "/supabase/import"
    }
  }
}
```

## Parameters

<span aria-hidden="true" id="interpolate"></span>



### `interpolate`

Controls whether Assembly Variables are interpolated for individual instruction fields.

By default, most Robot instruction fields interpolate Assembly Variables. Set this to `false` to treat every instruction field as literal text, or set an individual field path to `false` to treat only that field as literal text. For Robot-specific fields that are literal by default, set this to `true` or set that field path to `true` to opt back into interpolation.

Use field names such as `path`, or dotted paths such as `ffmpeg.vf` for nested objects.

Type: `boolean | Record<string, boolean>`

<span aria-hidden="true" id="output_meta"></span>



### `output_meta`

Allows you to specify a set of metadata that is more expensive on CPU power to calculate, and thus is disabled by default to keep your Assemblies processing fast.

For images, you can add `"has_transparency": true` in this object to extract if the image contains transparent parts and `"dominant_colors": true` to extract an array of hexadecimal color codes from the image.

For images, you can also add `"blurhash": true` to extract a [BlurHash](https://blurha.sh) string — a compact representation of a placeholder for the image, useful for showing a blurred preview while the full image loads.

For images, `"thumbhash": true` instead extracts a base64-encoded [ThumbHash](https://evanw.github.io/thumbhash/) into `meta.thumbhash`, together with `meta.has_alpha` (whether an alpha channel exists, even when fully opaque). It describes EXIF-oriented pixels and uses the first frame of animated images. Extraction is best-effort: images above 40 megapixels, unsupported formats, or a failed/bounded decode produce no placeholder. Successful extraction adds a metadata charge equivalent to 20% of that file's bytes. No ThumbHash surcharge applies when disabled or when no hash is produced.

Set this option on the Step producing the image, such as `/upload/handle` for uploaded originals or `/image/resize` for processed outputs. Setting it only on `/transloadit/store` does not request extraction: storage preserves the producer's metadata. Transloadit Storage persists a generated hash with its immutable version and returns it in stored results and native asset reads. Direct S3 uploads do not generate placeholders. A placeholder contains image information, so protect it with the same access controls as the full image.

For videos, you can add the `"colorspace": true` parameter to extract the colorspace of the output video.

For videos, you can also add `"interlaced": true` to detect whether the video is interlaced. This combines the cheap ffprobe `field_order` flag with a bounded `idet` sampling pass over the first frames of the source, exposing `interlaced`, `field_order`, and a diagnostic `interlace_detection` object under `file.meta`. This is computationally expensive and billed accordingly.

For audio, you can add `"mean_volume": true` to get a single value representing the mean average volume of the audio file.

You can also set this to `false` to skip metadata extraction and speed up transcoding.

Type: `Record<string, boolean> | boolean | Array<string>`

<span aria-hidden="true" id="user_meta"></span>



### `user_meta`

Adds custom JSON metadata to each emitted file without changing its contents. Nested objects and arrays are supported.

Inheritance depends on the Robot. Values merge with existing `user_meta` on the output file; the current Step replaces matching top-level keys. Assign required keys explicitly when a Robot creates fresh outputs.

In processing Steps, `${file.*}` refers to the first input and `${result.*}` to the emitted file. Values are evaluated per output after the Robot runs, before subsequent metadata extraction and temporary storage. On `:original`, values are evaluated per upload before metadata extraction.

Downstream Steps read `${file.user_meta.key}`. See [Custom metadata](https://transloadit.com/docs/topics/assembly-variables.md#user-meta) for a complete example and inheritance rules.

Type: `Record<string, any>`

Default: `{}`

<span aria-hidden="true" id="result"></span>



### `result`

Whether the results of this Step should be present in the Assembly Status JSON

Type: `boolean`

Default: `false`

<span aria-hidden="true" id="queue"></span>



### `queue`

Setting the queue to 'batch', manually downgrades the priority of jobs for this step to avoid consuming Priority job slots for jobs that don't need zero queue waiting times

Type: `batch`

<span aria-hidden="true" id="force_accept"></span>



### `force_accept`

Force a Robot to accept a file type it would have ignored.

By default, Robots ignore files they are not familiar with.
[🤖/video/encode](/docs/robots/video-encode.md), for
example, will happily ignore input images.

With the `force_accept` parameter set to `true`, you can force Robots to accept all files thrown at them.
This will typically lead to errors and should only be used for debugging or combatting edge cases.

Type: `boolean`

Default: `false`

<span aria-hidden="true" id="ignore_errors"></span>



### `ignore_errors`

Ignore errors during specific phases of processing.

Setting this to `["meta"]` will cause the Robot to ignore errors during metadata extraction.

Setting this to `["execute"]` will cause the Robot to ignore errors during the main execution phase.

Setting this to `["import"]` will cause the Robot to ignore errors while importing the source file. The `"import"` phase is only available to import Robots.

Setting this to `true` is equivalent to `["meta", "import", "execute"]` and will ignore errors in all three phases.

Type: `boolean | Array<meta | import | execute>`

Default: `[]`

<span aria-hidden="true" id="force_name"></span>



### `force_name`

Custom name for the imported file(s). By default file names are derived from the source.

Type: `string | Array<string> | null`

Default: `null`

<span aria-hidden="true" id="import_on_errors"></span>



### `import_on_errors`

Setting this to `["meta"]` will still import the file on metadata extraction errors. `ignore_errors` is similar, it also ignores the error and makes sure the Robot doesn't stop, but it doesn't import the file.

Type: `Array<meta>`

Default: `[]`

<span aria-hidden="true" id="credentials"></span>



### `credentials`

Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your Supabase bucket, Key, Secret and Bucket region.

While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> is too unwieldy because of their static nature. If you have this requirement, feel free to use the following parameters instead: `"bucket"`, `"host"`, `"key"`, `"secret"`.

If you do use these parameters, make sure to use the **Endpoint** value under `Storage > S3 Connection` in the Supabase console for the `"host"` value, and the values under **S3 Access Keys** on the same page for your `"key"` and `"secret"`.

Type: `string`

<span aria-hidden="true" id="bucket"></span>



### `bucket`

Type: `string`

<span aria-hidden="true" id="bucket_region"></span>



### `bucket_region`

The region where the bucket is located.

Type: `string`

<span aria-hidden="true" id="host"></span>



### `host`

Type: `string`

<span aria-hidden="true" id="key"></span>



### `key`

Type: `string`

<span aria-hidden="true" id="secret"></span>



### `secret`

Type: `string`

<span aria-hidden="true" id="path"></span>



### `path`

The path in your bucket to the specific file or directory. If the path points to a file, only this file will be imported. For example: `images/avatar.jpg`.

If it points to a directory, indicated by a trailing slash (`/`), then all files that are direct descendants of this directory will be imported. For example: `images/`.

Directories are **not** imported recursively. If you want to import files from subdirectories and sub-subdirectories, enable the `recursive` parameter.

If you want to import all files from the root directory, please use `/` as the value here. In this case, make sure all your objects belong to a path. If you have objects in the root of your bucket that aren't prefixed with `/`, you'll receive an error: `A client error (NoSuchKey) occurred when calling the GetObject operation: The specified key does not exist.`

You can also use an array of path strings here to import multiple paths in the same <dfn>Robot</dfn>'s <dfn>Step</dfn>.

Type: `string | Array<string>` — Required

<span aria-hidden="true" id="recursive"></span>



### `recursive`

Setting this to `true` will enable importing files from subfolders and sub-subfolders, etc. of the given path.

Please use the pagination parameters `page_number` and `files_per_page` wisely here.

Type: `boolean`

Default: `false`

<span aria-hidden="true" id="page_number"></span>



### `page_number`

The pagination page number. For now, in order to not break backwards compatibility in non-recursive imports, this only works when recursive is set to `true`.

When doing big imports, make sure no files are added or removed from other scripts within your path, otherwise you might get weird results with the pagination.

Type: `string | number`

Default: `1`

<span aria-hidden="true" id="files_per_page"></span>



### `files_per_page`

The pagination page size. This only works when recursive is `true` for now, in order to not break backwards compatibility in non-recursive imports.

Type: `string | number`

Default: `1000`

<span aria-hidden="true" id="return_file_stubs"></span>



### `return_file_stubs`

If set to `true`, the Robot will not yet import the actual files but instead return an empty file stub that includes a URL from where the file can be imported by subsequent Robots. This is useful for cases where subsequent Steps need more control over the import process, such as with 🤖/video/ondemand. This parameter should only be set if all subsequent Steps use Robots that support file stubs.

Type: `boolean`

Default: `false`