Automate ShotGrid Version creation from Publish events

A Publish appears, but no Version follows

An artist registers a Publish in ShotGrid, but the matching Version never gets created. The compositor opens the linked Task, finds no media to review, and the shot stalls while someone manually creates the Version and connects it to the Task. This gap is common in ShotGrid pipelines: a Publish is recorded, but the downstream Version that review and editorial depend on is missing.

The practical fix is to automate the reaction. A ShotGrid Event Daemon plugin can watch for Publish registration and create the Version for you. The catch is that you operate the daemon yourself, so it needs monitoring and least-privilege credentials.

What the Event Daemon actually does

ShotGrid uses entities such as Publish, Version, and Task. An event is a change to an entity, like a new Publish being created. The Event Daemon is a long-running Python process you host. It subscribes to these events and runs registered event plugins when they fire.

A plugin receives the triggering event, can query related entities through the ShotGrid Python API, and can write back to ShotGrid or call external systems. This is not serverless code managed by ShotGrid. It runs on infrastructure you operate, so if the process stops, automated reactions stop until it is restarted.

Worked example: create a Version when a Publish registers

Goal: when a Publish is created in a project, automatically create a Version, link it to the Publish and its Task, and set a default status.

In ShotGrid Admin, open Event Daemon plugin management. Create or edit a plugin, set the event filter to Publish creation events, and provide the plugin code. Exact event names vary by ShotGrid version, so confirm the filter values in your Admin UI before saving.

This is a representative plugin pattern, not tested code:

import shotgun_api3

def register_callback(reg):
    reg.subscribe(
        entity_type='Publish',
        event_type='created',  # Confirm exact event name in ShotGrid Admin
        callback_fn=publish_created_callback
    )

def publish_created_callback(sg, logger, args):
    publish_id = args['meta']['entity_id']
    publish = sg.find_one(
        'Publish',
        [['id', 'is', publish_id]],
        ['task', 'code', 'project', 'sg_uploaded_movie']
    )
    if not publish or not publish.get('task'):
        logger.warning('Publish %s has no Task; skipping', publish_id)
        return

    task_id = publish['task']['id']
    version_data = {
        'entity': {'type': 'Task', 'id': task_id},
        'code': publish.get('code') or 'Untitled Version',
        'sg_status_list': 'rev',
        'description': 'Auto-created from Publish %s' % publish_id,
    }
    sg.create('Version', version_data)
    logger.info('Created Version for Task %s from Publish %s', task_id, publish_id)

Run this plugin on the host where your Event Daemon runs. Required permissions: a ShotGrid script user or service account that can read Publish and Task and create Version. Do not use a personal user account for the daemon. Run connectivity checks from a workstation with network access to ShotGrid:

# Run locally or on the daemon host. Replace placeholders.
SG_SERVER=https://yourstudio.shotgrid.autodesk.com
python -c "
import os, shotgun_api3
sg = shotgun_api3.Shotgun(
    os.environ['SG_SERVER'],
    script_name=os.environ['SG_SCRIPT_NAME'],
    api_key=os.environ['SG_API_KEY']
)
print(sg.find_one('Task', [['id', 'is', 12345]], ['code']))
"

Expected check: the command prints the Task code. Risk: never print or commit the API key; use environment variables and restrict the script role to the entities it needs.

Verify before you trust it

1. In ShotGrid Admin, confirm the plugin is installed and its event filter matches Publish creation.
2. Install the ShotGrid Python API locally and run a read-only query against a test entity to validate connectivity and permissions.
3. Create a test Publish in a sandbox project.
4. Open the linked Task in ShotGrid and confirm a Version appears and is linked to the Publish.
5. If no Version appears, check the Event Daemon logs and ShotGrid event history for plugin errors.

Limits and rollback

The Event Daemon is a single operational dependency. If it stops, Version creation stops. Run it under a process supervisor and alert on daemon downtime. Event delivery is not guaranteed real-time; latency depends on daemon polling and queue backlog.

Because the plugin writes to ShotGrid, it changes state. If a test run creates unwanted Versions in a sandbox, delete those Versions manually from the linked Tasks. In production, test the plugin on a non-critical project first and review the service account's permissions so it cannot modify or delete data outside its intended scope.

Closing

Automating Version creation from Publish events removes manual tracking and keeps review media connected to Tasks. Verify the plugin in a sandbox, confirm exact event filters in your ShotGrid Admin, and monitor the daemon before rolling it out to active projects.