There are some features that Enterprise plans have access to that other plans do not, but this isn’t specific to the API. Here’s a breakdown of features based on plan:

Frame.io

Compare plans - Elevate your creative workflow to an art form.

Free | Frame.io is the world’s leading creative review and collaboration platform. Share media, collect feedback, manage reviews, and deliver finished work faster — from anywhere in the world.

Your API access will mirror whatever features are included in your plan.

This isn’t a feature, but Enterprise plans are required to use S2S (server-to-server) authentication (although this is something we’re looking to solve for, and provide a solution for non-enterprise plan holders soon!)

If there’s anything specific you’s like clarified, feel free to follow up and I’ll be happy to help!

I am reaching out to clarify some conflicting information our team has been receiving in regards to the Frame io Enterprise API capabilities.

Is there additional API functionality available in Enterprise accounts as opposed to Team accounts?

Thanks

CM1776

We have a custom integration in place that uses the
https://api.frame.io/v2/review_links/{review_link_id}/items
endpoint.

I would love to know if we need to start working on implementing a workaround or if the data will be available in v4 by then.

Thanks!

Jannik

The Frame.io Python SDK v1.2.1 (frameio) now ships with a built-in uploader that handles chunked multi-part uploads to S3 end to end. No more hand-rolling pre-signed URL chunking, retry logic, or parallel PUT orchestration — the SDK takes care of it.

What’s New

The new frameio.upload module introduces FrameioUploader:

Uploads go directly from your application to S3 — they don’t pass through Frame.io’s API servers.

How to Try It

1. Install or upgrade the SDK

pip install frameio --upgrade

2. Upload a file

import os
from frameio import Frameio
from frameio.files import FileCreateLocalUploadParamsData
from frameio.upload import FrameioUploader

client = Frameio(token="YOUR_TOKEN")

file_path = "/path/to/video.mp4"
file_size = os.path.getsize(file_path)

# 1. Create the file resource and get pre-signed upload URLs
response = client.files.create_local_upload(
    account_id="YOUR_ACCOUNT_ID",
    folder_id="YOUR_FOLDER_ID",
    data=FileCreateLocalUploadParamsData(
        name="video.mp4",
        file_size=file_size,
    ),
)

# 2. Upload the file to S3
with open(file_path, "rb") as f:
    FrameioUploader(response.data, f).upload()

That’s it — the SDK chunks the file, uploads in parallel, and retries on failure.

3. Track progress

def on_progress(uploaded: int, total: int) -> None:
    pct = uploaded / total * 100
    print(f"\r{pct:.1f}% ({uploaded:,} / {total:,} bytes)", end="", flush=True)

with open(file_path, "rb") as f:
    FrameioUploader(response.data, f, on_progress=on_progress).upload()

For a polished terminal experience, plug the callback into a Rich progress bar:

from rich.progress import Progress, BarColumn, DownloadColumn, TransferSpeedColumn, TimeRemainingColumn

with Progress(
    "[progress.description]{task.description}",
    BarColumn(), DownloadColumn(), TransferSpeedColumn(), TimeRemainingColumn(),
) as progress:
    task = progress.add_task("Uploading...", total=file_size)
    with open(file_path, "rb") as f:
        FrameioUploader(
            response.data, f,
            on_progress=lambda done, total: progress.update(task, completed=done),
        ).upload()

Key Features

• Tunable parallelism — bump max_workers for high-bandwidth connections
• Configurable retries — raise max_retries on flaky networks (exponential backoff)
• Remote upload helper — skip chunking entirely when the file is already at a public URL:

from frameio.files import FileCreateRemoteUploadParamsData

response = client.files.create_remote_upload(
    account_id="YOUR_ACCOUNT_ID",
    folder_id="YOUR_FOLDER_ID",
    data=FileCreateRemoteUploadParamsData(
        name="video.mp4",
        source_url="https://example.com/video.mp4",
    ),
)

Remote upload currently has a 50 GB file size limit — use local upload for anything larger.

Checking Upload Status

After uploading, verify completion:

status = client.files.show_file_upload_status(
    account_id="YOUR_ACCOUNT_ID",
    file_id=response.data.id,
)
print(f"Upload complete: {status.data.upload_complete}")

Resources

• Python Upload Guide — full walkthrough with configuration, progress tracking, and a complete script
• How Local & Remote Uploads Work — the underlying API flow if you want full control
• SDK Reference — API reference

Feedback

We’d love to hear how it works for you. If you run into issues or have feature requests reply to this post!

We’ve set up a server in my company to do a OAuth Single-Page App. The server is reachable and is accepted at the Configure OAuth Single-Page App credential page. However at the page to Configure API when saved it says “API Configuration Failed: Please try again”. It is not clear what the issue is.

Is there a way of debugging to get this working please.

Joe

Internal comments aren’t currently supported through V4 API. The closest option at this time is to use a restricted project, although I know it’s not a 1:1 replacement.

I’ve gone ahead and filed a feature request for this, and will make sure to provide any updates on that here as they become available.

Feel free to let me know if you have any questions, or if there’s anything else we can help with.

Developer tokens generated at developer.frame.io do not work with V4 unless under very certain conditions at this time. You need to use the specific header outlined in our documentation here in order for it to work: https://next.developer.frame.io/platform/v4/docs/guides/authentication/python-sdk#legacy-developer-tokens

If it does not work for you then you do not meet the conditions and therefore must use OAuth via IMS to create an integration into Frame.io (OAuth apps created via developer.frame.io will not work). You can find more information about authentication here and how to get started here.

If you are using LLMs for your project, you can use our llms-full.txt which will give the entire context of our dev docs to the LLM to pull from.

Also I would highly recommend you use our Python SDK for Auth (Typscript Auth is coming soon) as it handles all the diifficult logic for you automatically.

Hi support,

We’re building an internal creative review dashboard that needs to pull video thumbnails via the API. Our account was migrated to Adobe infrastructure (from_adobe: true on our user profile).

What’s happening:

Our Developer Token (fio-u-…) successfully authenticates against GET /v2/me and returns our user profile (account ID: a4ce***********af4, user: hello@bu###.com)
However, ALL asset/project/folder endpoints return 404 Not Found on REST v2
GraphQL queries for assets return PERMISSION_DENIED
This includes projects and assets we can access fine in the web UI

What we need:

REST v2 GET /v2/assets/{asset_id} to return asset details including thumbnail URLs
Or GraphQL asset(assetId: “…”) queries to work
Specifically, we need thumb_256 / thumb_540 fields from video assets for display in our dashboard

Our project/folder IDs (accessible in web UI but not via API):

Project: b5df2802
Folder : all

Questions:

After Adobe migration, do Developer Tokens need to be regenerated with specific scopes?
Is there a different auth flow required for Adobe-migrated accounts (e.g. Adobe IMS tokens)?
Are there any workspace/team-level permissions that need to be enabled for API access?

Our Developer Token was generated from the developer portal. We also have OAuth client credentials configured (client_id: 2b72************************************6259) but the access token returns 401.

Thanks,

I’m hoping to present an example of what I want to do with my personal account to alleviate their concerns about something nefarious. So I wanted to make sure if I put the time into writing the code, it will translate over with just some variables changed since it’s a different account.

Thanks!

Also /v2 & /v4 are not compatible. The token created by IMS should not work for /v2/me if it does then something is not working correctly.

Also, would recommend you use the Python Auth SDK to see if that would work for you as well.

Setup:

• Scopes: openid, profile, email, offline_access, additional_info.roles

What works:

• GET /v2/me → 200 (returns user info)

• Adobe IMS token exchange → valid JWT

What fails (all 403):

• GET /v4/me

• GET /v4/accounts

• GET /v4/accounts/{id}/workspaces

The token is a valid Adobe IMS JWT. The /v2/me endpoint confirms the token is accepted. But all /v4/* routes return a plain 403 Forbidden HTML page (not a JSON error).

Is there an account-level provisioning step required for V4 API access? Or are we missing a scope?

For now, this will need to be completed for each share link. I will make sure to update this post as I receive any updates on the feature request created for this, including any estimate around development timeline if that becomes available.

If you don’t monitor the forum often and would prefer to be contacted directly, feel free to send over the best contact email in a private message and I’ll make sure you’re kept up to date as things progress.

It looks like you’re using | to separate your patterns, I’d try switching to a comma-separated list instead:

https://localhost:3000/api/auth/callback/frameio,https://staging-dashboard\\.mydomain\\.net/api/auth/callback/frameio,https://dashboard\\.mydomain\\.net/api/auth/callback/frameio

Related docs: https://developer.adobe.com/developer-console/docs/guides/authentication/UserAuthentication/implementation#redirect-uri-pattern

If that still doesn’t resolve it, I’d check the actual redirect_uri being sent from your staging environment and make sure it is matching that pattern exactly.

Redirect URI

https://dashboard.mydomain.net/api/auth/callback/frameio

Redirect URI Pattern

https://localhost:3000/api/auth/callback/frameio|https://staging-dashboard\\.mydomain\\.net/api/auth/callback/frameio|https://dashboard\\.mydomain\\.net/api/auth/callback/frameio

The redirect works fine for localhost, it’s just staging gets redirected to production instead.

Any ideas?

Thanks!

EDIT: They actually responded super quickly on the night before Good Friday . Account was flagged for using v3-exclusive features (likely API) and required manual override / consent to update.

Glad to hear you have been enjoying working with the V4 API. All of the V4 API endpoints work across all account types. Personal, Team and Enterprise. The same documentation on next.developer.frame.io applies to all of them regardless of plan.

I’m not sure what your team means by "special buckets” or “its own API”. That could refer to a few things depending on how your company’s account is configured. It would be worth asking your team for some more specifics so we can give you a clearer answer.

In the meantime you will need access to your org’s Developer Console to create OAuth credentials. Some enterprise orgs restrict this, so you may need your IT/admin team to give you access or set up OAuth credentials for you.

1. Set up the Metadata Value Updated to filter on New Field Value
   

   
   
   
   

2. Set up Show File to get the view url
   

   

3. Use the Custom API (SDK) action to get the List Account Permissions endpoint
   

   

4. Set up some Custom Code (Javascript) to extract the username from the raw output of the previous SDK step
   

   

const userId = inputData.userID;
const raw = inputData.stepOutput;

const idx = raw.indexOf(userId);
if (idx === -1) {
  return { userName: "Unknown User" };
}

const after = raw.substring(idx, idx + 500);
const nameMatch = after.match(/name[\\"]*\s*:\s*[\\"]*([\w\s]+)/);

return {
  userName: nameMatch ? nameMatch[1].trim() : "Unknown User"
};

5. Use that to have slack send me a message everytime a status is changed.
   
   
   
   
   

full zap looks like this

So does that mean the API endpoints in the V4 API documentation would not work if I were to connect my work adobe account? Should I even try?

This might be a niche question, but I’ve been so curious about it so if anyone knows or can sort of figure out what I’m talking about with me having to give specifics I’m not sure of or allowed to, that would be great.

Thanks!
Nancy

We’ve just added the /search endpoint to the experimental API! This endpoint calls the same search engines that power the search bar in the Frame.io web app. In fact, you can even choose which engine to run your search with.

We see this endpoint being incredibly useful for a lot of integrations and workflows, and would love to get some feedback on how it’s working for you. For feedback on quality of search results, we can route those to our search team if necessary – but we’d love to see feedback on the endpoint itself.

Getting Started

It’s incredibly simple to set up. All you need to do is choose your search engine (lexical for standard search or nlp for natural language/semantic search) and pass your search query. The endpoint will search across the specified account and return a list of matches.

data: {
  "engine": "nlp",
  "query": "YOUR SEARCH QUERY"
}

If you’d like you can also filter by asset type:

data: {
  "engine": "nlp",
  "query": "YOUR SEARCH QUERY",
  "filters":
    {
      "files_and_version_stacks": "true",
      "folders": "false",
      "projects": "false"
}

Advanced Workflows

You can even use the nlp engine to search against more specific parameters by using a tokenized query string. Let’s say your workflow needs to find assets based on filename, limited to a project, and with a specific Status value.

//Capture these from the user
filename = "my_file.mov"
project = "{project_id}"
status = "In Progress"

query_string = "{filename} in project {project_id} with Status {status}"

data: {
  "engine": "nlp",
  "query": query_string,
  "filters":
    {
      "files_and_version_stacks": "true",
      "folders": "false",
      "projects": "false"
}

Start with your zap open and the trigger selected just like in your still image.

In Frame.io import a new unique asset into your project then change the asset status to Approved. Only do it once.

In Zapier go to the test step, hit find new records. This should identify the most recent events that zapier detected in frame.io. It will present them as letters. We picked a unique asset so that it easy to identify.

You can click on them to see the name like in your screen cap. If the letters are trending towards the end of the alphabet or it seems messy, you can search for the name of the asset in the above search bar.

Find the event for the asset that you just uploaded and you should see Approved as New Field Value. With that record selected test the zap. That record will load your trigger with the event needed to configure your filter.

You will need to keep that event loaded into the trigger step when you are configuring the filter.

Here’s how to make the ‘Status’ field editable for anyone accessing it using a share link:

• Locate the share in your Project’s share links
• Open the Fields section in the share link settings
• Enable ‘allow edits’ using the toggle

Once edits are allowed, anyone that accesses the asset through the share link will be able to modify the ‘Status’ field.

I’ve gone ahead and submitted a feature request to make this (along with other field settings) configurable via API at share creation, and will make sure to keep you updated on that as I hear back.

Feel free to let me know if you have any questions!

Asset marked as Approved Uploads to Google Drive

This Zap monitors a metadata field, filters for “Approved” records, retrieves file details, and automatically uploads approved files to Google Drive.

The Logic Flow

1. Trigger → Detects when a metadata value changes (e.g., status field updated)

2. Filter → Only continues if the new value is “Approved” (exact match, case-insensitive)

3. Show File → Retrieves the full file object including its download URL

4. Action → Uploads that file to Google Drive in a designated folder

Step-by-Step Setup Instructions

Step 1: Set Up the Trigger

• App: Frame.io

• Trigger: “Metadata Value Updated”

• Configuration needed:

  • Account: Connect your account

  • Workspace: Select if applicable

    • This watches for ANY metadata change in that workspace

    • This feature is available only to enterprise accounts

Step 2: Add a Filter

• App: Filter by Zapier

• Condition: [field from trigger] = "Approved"

  • The current setup filters (the new metadata value)

  • Match type: text is exactly “Approved”

• Note: Additional filter parameters may need to be added depending on the complexity of your workspace and project layout.

• Note: You will need to run approved trigger in Frame.io! Zapier needs to see the action happen in Frame.io to set the zap up correctly. Test this step!

• Result: Only proceed if status changes TO “Approved”

Step 3: Show File

• App: Frame.io

• Action: “Show File”

• Configuration needed:

  • Account & Workspace: Same as trigger

  • Project ID: (the specific project)

  • File ID: *Custom* (the file ID from the trigger step 1)

  • Include: media_links.original (to get the download URL)

• Note: Show File with media_links.original surfaces the download URL. The view URL will not move the file.

• Output: File object with original_download_url for Step 4

Step 4: Upload to Google Drive

• App: Google Drive

• Action: “Upload File”

• Configuration needed:

  • Drive: “My Google Drive”

  • Folder: the destination folder within Google Drive

  • File: {["original_download_url"]} (the download URL from Step 3)

• Result: File uploaded to the specified folder

Be sure to test your configurations and filters.

Following up with a quick example of the changes Charlie mentioned just in case it helps get things unblocked faster. (One thing to note is that this assumes you only have one account ID to work with. If you have multiple, you’ll want to adjust the index):

  import frameio                                                                                                                                                 
   
  token = "<token>"                                                                                                                                              
                  
  client = frameio.Frameio(
      token=token,
      headers={"x-frameio-legacy-token-auth": "true"},
  )                                                                                                                                                              
   
  account_id = client.accounts.index().items[0].id                                                                                                               
                  
  client.workspaces.index(account_id=account_id)  

We’ve been using the Frame.io v2 api (via the python SDK) for some time now. Today our users have been unable to get our tools to work. client.teams.list_all() was returning an empty list.

I did some digging and saw there was a new V4 api so I wanted to give that a shot (via the new python SDK). Following the migration guide I added `x-frameio-legacy-token-auth` to the headers so we can continue to use our legacy tokens and now when I run: client.workspaces.index(<user_id>) I get a 401 unauthorized error code. I’m able to get_me().

We have to use the legacy tokens since we currently do not license frame.io through adobe but still through our original plan.

Is there some authorization limitations with the legacy tokens? Is there some other issue I’m not aware of?

import frameio

token = "<token>"

headers = {'x-frameio-legacy-token-auth': 'true'}
client = frameio.Frameio(token=token, headers=headers)

client_data = client.users.show()
account_id = client.users.show().data.id

client.workspaces.index(account_id=account_id) # Raises 401 error.

Thank you for your help!

tldr; you need to create a project in the developer console and add the frame.io API to your project, and select your user auth depending on what you are looking to accomplish.

You can find more information about what credential types does what on our Authorization doc.

a couple o questions:

• do i have to recreate all the: toke, client id, account id on developer.adobe.com or developer.frame.io
• which API type do i choose in the project OAuth Web App,OAuth Single-Page App or OAuth Native App

thanks
Andrea

I’ll have someone on my team take a look and get back to you.