# Import videos from Vimeo

Robot: `/vimeo/import`

🤖/vimeo/import imports videos from your Vimeo account.

Stage: ga

## Usage example

Import videos from your Vimeo account:

```json
{
  "steps": {
    "imported": {
      "robot": "/vimeo/import",
      "credentials": "YOUR_VIMEO_CREDENTIALS",
      "path": "me/videos",
      "rendition": "720p",
      "page_number": 1,
      "files_per_page": 20
    }
  }
}
```

## Parameters

* `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.

* `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 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.

* `user_meta`: Adds custom metadata to each file emitted by this Robot without modifying the file’s contents.

  The values are merged with any existing `user_meta` carried by the input file. If both objects contain the same key, this Robot’s value takes precedence. Assembly Variables are supported, for example `{ "internal_file_id": "${file.id}" }`.

* `result`: Whether the results of this Step should be present in the Assembly Status JSON

* `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

* `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.

* `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.

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

* `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.

* `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 Vimeo access token.

* `path`: The Vimeo API path to import from. The most common paths are:

  * `me/videos`: Your own videos
  * `me/likes`: Videos you've liked
  * `me/albums/:album_id/videos`: Videos from a specific album
  * `me/channels/:channel_id/videos`: Videos from a specific channel
  * `me/groups/:group_id/videos`: Videos from a specific group
  * `me/portfolios/:portfolio_id/videos`: Videos from a specific portfolio
  * `me/watchlater`: Videos in your watch later queue

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

* `page_number`: The page number to import from. Vimeo API uses pagination for large result sets.

* `files_per_page`: The number of files to import per page. Maximum is 100 as per Vimeo API limits.

* `rendition`: The quality of the video to import.