Autodesk Platform Services and Fusion Automation

Overview#

The desktop API runs inside a Fusion window that a person is sitting in front of. Autodesk Platform Services (APS, formerly Forge) is the other half of the story: a set of cloud web APIs that work with the same data from anywhere, without Fusion open. If you want a web dashboard that lists every Fusion design in a project, a button that converts a design to a viewable format in a browser, or a nightly job that processes files, you are in APS territory.

This page covers four things (the first three are not confirmed in the Fusion documentation, as noted above):

1. Getting started: an APS application, credentials, and OAuth.
2. Data Management API: hubs, projects, folders, items and versions, the programmatic view of the Fusion data panel.
3. Model Derivative API: translating files and extracting metadata, plus the Viewer.
4. Design Automation and Fusion automation: running engines in the cloud, and the realistic options for unattended Fusion work.

What Autodesk's Fusion documentation actually says#

The Fusion help mirror used for this fact-check covers the desktop API in depth but contains almost nothing about the general APS web services. These statements are confirmed there:

• Design Automation API for Fusion: the 2025 release notes (May 2025 section, under "Fusion Design API") list "Commercial release of the Design Automation API for Fusion". No further detail is in the mirror.
• Fusion Automation API service (TypeScript): Autodesk's TypeScript topic says scripts can run "on the Fusion Automation API service". They import from @adsk/fusion/automation, which "provides only the subset of the API that is available in the service environment"; calls outside that subset "can fail at runtime". Scripts log with adsk.log(...). File system access in both desktop and service modes is sandboxed to a temporary directory, and fetch, timers and Base64 helpers are available. One TypeScript sample falls back to a folder named "Fusion Automation Service" when the document is not in a project.
• VS Code extension: System Modeler's developer setup uses the "Fusion Automation API" extension (publisher Autodesk), which "also supports remote script runs via Autodesk Platform Services (APS), which requires a Client ID and Client Secret".
• Manufacturing Data Model (MFGDM) API: a cloud GraphQL service for design data. The 2024 release notes say it gained custom properties, configurations, administration capabilities and geometry export options ("Visit Autodesk Platform Services for more information"). The desktop API links to it through DataComponent.mfgdmModelId and timestamp (from design.rootDataComponent or occurrence.dataComponent) and the MFGDMDataReady event. A modelId is a timeless identifier; a componentId is time specific. Part number and description are now cloud properties that require a saved document.
• Fusion MCP servers: the local Autodesk Fusion MCP Server (needs Fusion running; enabled in Preferences > General > API; no authentication, local connection only) and the cloud Autodesk Fusion Data MCP Server (hubs, projects, folders, items; needs an Autodesk account and network access to https://developer.api.autodesk.com; no Fusion install needed). Compatible clients include Claude Desktop, Cursor and VS Code.
• Autodesk Assistant: the 2026 release notes say scripts can be written and executed against the Fusion API from Autodesk Assistant.
• Desktop API cloud access: Application.data (Data), Data.activeProject, Data.dataHubs (hubs are "A360 Team or Personal" hubs), DataProject.rootFolder, DataFolder.dataFiles / dataFolders, DataFile.fileExtension, Documents.open, Documents.openUsingContext (open a specific version or timestamp).

Note: not confirmed in Autodesk's documentation (the Fusion help mirror): everything else on this page about the general APS services, namely OAuth flows and token endpoints, scopes, Data Management and Model Derivative endpoints, SVF2 and the Viewer, OSS buckets, webhooks, Design Automation endpoints and engine lists, quotas and pricing. It is general APS knowledge written from memory of aps.autodesk.com. Each section below repeats the label; verify against the current APS documentation before building.

Where to find it#

• The APS developer portal at aps.autodesk.com (not confirmed in the Fusion documentation): sign in with an Autodesk account, create an application, and receive a Client ID and Client Secret. The Fusion documentation confirms only that remote script runs need a Client ID and Client Secret.
• The APS documentation and API reference pages for each service (not in the mirror).
• Hub provisioning (not confirmed): for an application to see a hub's data, a hub administrator may need to provision the Client ID. The mechanism differs for Autodesk Construction Cloud and Fusion hubs.

Concepts#

Authentication#

Note: not confirmed in Autodesk's documentation (this whole subsection is general APS knowledge).

APS uses OAuth 2.0. There are two flows:

Reading Fusion hub data requires three-legged tokens with scopes such as data:read, plus data:write, data:create when you modify things, and viewables:read for viewing. Scope names are listed in the documentation. Access tokens expire (typically within an hour), so refresh them. APS has also introduced newer token endpoints over time (v1 and v2 authentication), so check which is current.

A two-legged token in Python:

import requests

CLIENT_ID = 'YOUR_CLIENT_ID'
CLIENT_SECRET = 'YOUR_CLIENT_SECRET'

def get_two_legged_token(scope='data:read data:write bucket:create bucket:read'):
    resp = requests.post(
        'https://developer.api.autodesk.com/authentication/v2/token',
        auth=(CLIENT_ID, CLIENT_SECRET),                # HTTP Basic
        data={'grant_type': 'client_credentials', 'scope': scope},
        timeout=30)
    resp.raise_for_status()
    return resp.json()['access_token']

The v2 endpoint takes Basic authentication with the client id and secret, form-encoded grant_type and scope. The older /authentication/v1/authenticate endpoint was deprecated.

Keep the secret on a server. General guidance: never embed it in a palette, a distributed add-in, or browser code (a palette's JavaScript is user-visible). If your Fusion add-in needs APS access, have it call your own small web service, which holds the secret.

Fusion data and the hub model#

Note: not confirmed in Autodesk's documentation as an APS REST model; the desktop API's version of the same hierarchy (hub, project, folder, file, version) is confirmed in the Data* classes listed above.

In APS, the content of a Fusion team or hub is addressed as a hierarchy:

Hub  >  Project  >  Folder (nested)  >  Item  >  Version

• A hub is a Fusion team (or an Autodesk Docs account).
• A project is a Fusion project.
• A folder is a folder in the data panel; topFolders give the root.
• An item is a design (or other file) as a logical file.
• A version is a saved revision; each save creates a new version.

Ids are long strings with URN-like forms such as urn:adsk.wipprod:fs.file:vf.XXXX?version=3. Always treat them as opaque and URL-encode them when used in paths.

Data Management API#

Note: not confirmed in Autodesk's documentation: every endpoint, response shape and upload step in this section. The Fusion documentation instead points to the MFGDM GraphQL API and the Fusion Data MCP server (above) for hubs, projects, folders and items; check which suits your project.

The base is https://developer.api.autodesk.com (this host is confirmed, because the Fusion Data MCP topic names it). The core resources follow the JSON:API style.

A Python walk of a project's top folders, given a three-legged token:

import requests

BASE = 'https://developer.api.autodesk.com'

def api_get(path, token, params=None):
    r = requests.get(BASE + path,
                     headers={'Authorization': f'Bearer {token}'},
                     params=params, timeout=30)
    r.raise_for_status()
    return r.json()

def list_hubs(token):
    return [(h['id'], h['attributes']['name']) for h in api_get('/project/v1/hubs', token)['data']]

def list_projects(token, hub_id):
    data = api_get(f'/project/v1/hubs/{hub_id}/projects', token)['data']
    return [(p['id'], p['attributes']['name']) for p in data]

def list_folder(token, project_id, folder_id):
    data = api_get(f'/data/v1/projects/{project_id}/folders/{folder_id}/contents', token)['data']
    return [(d['type'], d['id'], d['attributes'].get('displayName')) for d in data]

def top_folders(token, hub_id, project_id):
    return api_get(f'/project/v1/hubs/{hub_id}/projects/{project_id}/topFolders', token)['data']

Responses are paginated. Follow links.next.href until absent. Fusion designs appear as items of type items:autodesk.fusion360:Design. Their latest version carries a derivatives relationship that points to a Model Derivative URN (the base64-encoded version id), which feeds directly into the viewing step below.

Uploads to Fusion hubs follow a multi-step process: create a storage location (POST .../storage), upload bytes to the returned signed S3 location (the Object id yields a signed URL via the OSS signed-upload endpoints), and then create the item or a new version referencing that storage. Uploading a native .f3d that Fusion treats as a proper cloud document has had restrictions; uploading neutral formats such as STEP is more dependable.

Model Derivative API#

Note: not confirmed in Autodesk's documentation: this entire section (job bodies, formats, manifest polling, metadata endpoints, Viewer URLs and versions, token handling). Verify against the APS documentation.

The Model Derivative API converts source files into other formats and extracts data. The common use is making a design viewable in a browser.

Translating#

1. Make sure the file is addressable by a URN, the base64 (URL-safe, without padding) encoding of the object id. For a file in your own OSS bucket the id is urn:adsk.objects:os.object:{bucket}/{objectName}; for a Fusion data version, use the version id from Data Management.
2. Post a translation job:

import base64, requests, time

def to_urn(object_id):
    return base64.urlsafe_b64encode(object_id.encode()).decode().rstrip('=')

def start_translation(token, urn):
    body = {
        'input': {'urn': urn},
        'output': {'formats': [{'type': 'svf2', 'views': ['2d', '3d']}]}
    }
    r = requests.post(
        'https://developer.api.autodesk.com/modelderivative/v2/designdata/job',
        headers={'Authorization': f'Bearer {token}', 'Content-Type': 'application/json'},
        json=body, timeout=30)
    r.raise_for_status()
    return r.json()

def wait_for_manifest(token, urn, interval=5, max_wait=600):
    waited = 0
    while waited < max_wait:
        r = requests.get(
            f'https://developer.api.autodesk.com/modelderivative/v2/designdata/{urn}/manifest',
            headers={'Authorization': f'Bearer {token}'}, timeout=30)
        r.raise_for_status()
        m = r.json()
        if m.get('status') in ('success', 'failed', 'timeout'):
            return m
        time.sleep(interval)
        waited += interval
    raise TimeoutError('Translation did not finish')

The output type svf2 is the modern streaming format for the viewer; svf is the older one; other outputs include obj, stl, step, iges, thumbnail. Which output formats a given input supports is a table in the documentation. Fusion native files translate as inputs, but the exact support and behaviour for references and assemblies depend on how the file was stored. Translation consumes service quota or cloud credits depending on your agreement, so watch costs.

Extracting metadata and properties#

After success, GET /modelderivative/v2/designdata/{urn}/metadata lists the model views (with a guid each), .../metadata/{guid} returns the object tree, and .../metadata/{guid}/properties returns properties for every object. This is how you build bills of materials or parameter reports outside Fusion.

Viewing in a browser#

The APS Viewer is a JavaScript library. A minimal page that loads a translated model needs a token fetched from your server:

<link rel="stylesheet" href="https://developer.api.autodesk.com/modelderivative/v2/viewers/7.*/style.min.css">
<script src="https://developer.api.autodesk.com/modelderivative/v2/viewers/7.*/viewer3D.min.js"></script>
<div id="viewer" style="width:100%;height:600px"></div>
<script>
  const urn = 'dXJuOmFkc2sub2JqZWN0czpvcy5vYmplY3Q6...';   // base64 urn
  const options = {
    env: 'AutodeskProduction2',
    api: 'streamingV2',
    getAccessToken: (callback) => {
      fetch('/api/token').then(r => r.json()).then(t => callback(t.access_token, t.expires_in));
    }
  };
  Autodesk.Viewing.Initializer(options, () => {
    const viewer = new Autodesk.Viewing.GuiViewer3D(document.getElementById('viewer'));
    viewer.start();
    Autodesk.Viewing.Document.load('urn:' + urn,
      (doc) => viewer.loadDocumentNode(doc, doc.getRoot().getDefaultGeometry()),
      (code, msg) => console.error('Load failed', code, msg));
  });
</script>

The version path (7.*) and the environment strings (AutodeskProduction2 with streamingV2 for SVF2) are as published in the viewer tutorials at the time of writing; check the current version and options. The token handed to the browser should be a narrowly scoped, read-only (viewables:read) token generated server-side.

Design Automation API#

Design Automation (general APS knowledge, not in the Fusion documentation) runs Autodesk engines on Autodesk's servers, driven by your code. You package a plug-in as an AppBundle, define an Activity (the command line and parameters), and submit WorkItems with inputs and output locations.

What the Fusion documentation adds: Autodesk's May 2025 release notes announce the "Commercial release of the Design Automation API for Fusion", so Fusion is now offered as a Design Automation target. The mirror does not say how it is used, which engine name or version applies, how a Fusion AppBundle is built, what is billed, or which endpoints differ. Autodesk's TypeScript topic suggests the Fusion route is script based: TypeScript scripts importing @adsk/fusion/automation, the same subset as the "Fusion Automation API service". Earlier drafts of this page said Fusion had "historically not been offered" as an engine and listed AutoCAD, Revit, Inventor and 3ds Max as the established engines; the first is outdated, and the engine list is not confirmed.

The generic workflow, from general APS knowledge, is:

1. Write a plug-in using that engine's API.
2. Zip it into an AppBundle and POST /da/us-east/v3/appbundles.
3. Define an Activity and POST /da/us-east/v3/activities.
4. Submit a WorkItem: POST /da/us-east/v3/workitems, with input URLs and signed output URLs.
5. Poll the WorkItem status and fetch results.

Endpoint paths include a region segment and version (not confirmed in the Fusion documentation).

Fusion automation: what is realistic#

"Automating Fusion" covers several approaches. The first two use only documented desktop API calls; the third and fourth are documented by Autodesk; the last rows are general APS ideas that the mirror does not confirm.

A batch script that exports every design in a folder (and its subfolders) to STEP, running inside Fusion. Every call below is in the reference or in Autodesk's samples: Data.activeProject, DataProject.rootFolder, DataFolder.dataFiles and dataFolders, DataFile.fileExtension and name, Documents.open(dataFile, True) (Autodesk's samples call it with True for visible), Document.close(False) (do not save), and ExportManager.createSTEPExportOptions(filename).

import adsk.core, adsk.fusion, traceback, os, re

def safe_name(text):
    return re.sub(r'[^\w\-. ]', '_', text)

def export_folder(app, folder, out_dir, log):
    for df in folder.dataFiles:
        if df.fileExtension != 'f3d':
            continue
        doc = None
        try:
            doc = app.documents.open(df, True)           # True = visible
            design = adsk.fusion.Design.cast(doc.products.itemByProductType('DesignProductType'))
            if not design:
                continue
            path = os.path.join(out_dir, safe_name(df.name) + '.step')
            mgr = design.exportManager
            mgr.execute(mgr.createSTEPExportOptions(path))
            log.append(df.name)
        except:
            app.log('Export failed for {}:\n{}'.format(df.name, traceback.format_exc()))
        finally:
            if doc:
                doc.close(False)                         # do not save
        adsk.doEvents()
    for sub in folder.dataFolders:                       # recurse
        export_folder(app, sub, out_dir, log)

def run(context):
    ui = None
    try:
        app = adsk.core.Application.get()
        ui = app.userInterface
        dlg = ui.createFolderDialog()
        dlg.title = 'Output folder'
        if dlg.showDialog() != adsk.core.DialogResults.DialogOK:
            return
        done = []
        export_folder(app, app.data.activeProject.rootFolder, dlg.folder, done)
        ui.messageBox('Exported {} designs to\n{}'.format(len(done), dlg.folder))
    except:
        if ui:
            ui.messageBox('Failed:\n{}'.format(traceback.format_exc()))

Autodesk's Documents reference says closing or creating documents is not supported inside command-related events, so run this from run, not from an event handler of a command. > Note: not confirmed in Autodesk's documentation: whether DataFile.name includes the file extension, and how Fusion prompts for missing references or upgrades when opening; test an attended run on a few files first. Files are processed in the main thread, so Fusion is unresponsive during the run.

Options reference#

Everything in this table is general APS knowledge, not confirmed in the Fusion documentation, except where the Fusion topics above say otherwise.

Tips and pitfalls#

Tip: General guidance: develop against a throwaway project and a small test model, and log full response bodies on failure.

Warning: General guidance: never expose your Client Secret in client-side code or a distributed add-in.

Warning: General guidance: do not hard-code endpoints or scopes copied from old tutorials; check the current APS documentation.

Note: not confirmed in Autodesk's documentation: how Fusion licence types (Personal use, commercial) interact with automation and APS billing. Check your licence terms and APS plan before building a service for customers.

Practice exercise#

Create an APS application and a two-legged token script. Upload a small STEP file to a bucket (PUT via the signed upload flow documented for OSS), start an SVF2 translation, poll until success, and then load it in the viewer page above, served from a local web server that exposes /api/token. Expected result: your model rotates in the browser. Bonus: use three-legged OAuth to list the hubs and projects of your own Fusion account (general APS behaviour; hub provisioning may be required). Alternative using only documented Fusion features: write a desktop script that lists app.data.dataHubs, their projects and root folders.

Related#

• Fusion API overview
• Packaging and distributing add-ins
• Event handlers