Automated Export Validation in Blender

In a high-volume asset pipeline, export problems are rarely dramatic. They are small: unapplied scale, a wrong prefix, a hidden mesh, a missing texture path, a modifier that was never evaluated, or an axis setting that differs from the receiving engine.

Those small problems become expensive when they are discovered after delivery. A Blender export tool should therefore behave like a preflight gate: validate first, export second, and produce a report that another person can understand.

For a technical art lead, the script’s value is not exporting faster. It is stopping repeated assets from shipping with the same invisible defect.

The code examples focus on Blender Python (bpy) patterns that can be adapted for FBX, USD, glTF, or studio-specific exporters.

01. Validation Should Flag Before It Fixes

Silent auto-fixes are dangerous in production. If a script changes scale, renames objects, rewrites paths, applies modifiers, or deletes invalid geometry without a report, the artist loses traceability.

The trade-off is speed versus accountability. A tool can fix simple mistakes, but it should first show what changed, why it changed, and who approved the rule.

A safer pattern:

1. collect the assets intended for export
2. run checks against source and evaluated scene data
3. report all blockers and warnings
4. stop export when blockers exist
5. export only when the report passes
6. save the report with the delivery package

Use warnings for issues a lead can approve. Use errors for issues that will break import, automation, or downstream use.

02. Core Preflight Checks

Start with checks that catch the most common handoff failures:

• object prefixes match the destination rules
• transforms are applied or intentionally documented
• origin and pivot placement match the target
• mesh data exists and contains faces
• no unexpected cameras, lights, helpers, or hidden delivery objects are selected
• material slots are named and assigned
• texture paths resolve from the .blend file or export root
• collection membership matches the package structure
• export format settings are consistent with the target engine

Here is a compact baseline validator:

import bpy
from pathlib import Path

VALID_PREFIXES = ("SK_", "SM_", "ACC_")
EPSILON = 0.001


def is_close_to_one(value):
    return abs(value - 1.0) <= EPSILON


def validate_object(obj):
    errors = []
    warnings = []

    if not obj.name.startswith(VALID_PREFIXES):
        errors.append(f"NAME_ERROR: {obj.name} must start with {VALID_PREFIXES}")

    if obj.type != "MESH":
        warnings.append(f"TYPE_WARNING: {obj.name} is {obj.type}, not MESH")
        return errors, warnings

    if any(not is_close_to_one(axis) for axis in obj.scale):
        errors.append(f"SCALE_ERROR: {obj.name} scale is {tuple(round(v, 4) for v in obj.scale)}")

    if obj.location.length > EPSILON:
        warnings.append(f"ORIGIN_WARNING: {obj.name} is offset from world origin")

    if not obj.data.polygons:
        errors.append(f"MESH_ERROR: {obj.name} has no faces")

    if not obj.material_slots:
        warnings.append(f"MATERIAL_WARNING: {obj.name} has no material slots")

    return errors, warnings

This is not enough for a complete production tool, but it establishes the correct behavior: report first, then decide.

03. Validate Evaluated Data, Not Only Source Objects

Modifiers, instances, geometry nodes, constraints, and collection instances can make the evaluated export different from the source object shown in the outliner.

When validation needs to match what the exporter will see, use the dependency graph:

def evaluated_mesh_for(obj, depsgraph):
    evaluated_obj = obj.evaluated_get(depsgraph)
    return evaluated_obj.to_mesh()


def validate_evaluated_geometry(obj, depsgraph):
    errors = []
    mesh = evaluated_mesh_for(obj, depsgraph)

    try:
        if not mesh.polygons:
            errors.append(f"EVAL_MESH_ERROR: {obj.name} evaluates to an empty mesh")

        if mesh.validate(clean_customdata=False):
            errors.append(f"EVAL_MESH_ERROR: {obj.name} contains invalid mesh data")
    finally:
        obj.evaluated_get(depsgraph).to_mesh_clear()

    return errors

Evaluated validation is especially important when the delivery relies on modifiers, geometry nodes, or export settings that apply modifiers at export time.

04. Check Texture Paths With Blender-Aware Path Handling

Blender supports // paths relative to the .blend file. Standard path handling can misread those if the script treats them like normal operating-system paths.

Use Blender’s path helpers:

def validate_image_paths():
    errors = []

    for image in bpy.data.images:
        if not image.filepath:
            continue

        absolute_path = Path(bpy.path.abspath(image.filepath))

        if not absolute_path.exists():
            errors.append(f"TEXTURE_PATH_ERROR: {image.name} missing at {absolute_path}")

    return errors

For a shipping exporter, also decide whether paths should be copied, made relative, embedded, or rewritten into a delivery folder. That decision should be part of the export preset, not a manual afterthought.

05. Batch by Collection, Not by Memory

Batch export becomes reliable when the file itself explains how assets are grouped.

Collection-based batching helps keep exports repeatable:

def exportable_collections():
    return [
        collection
        for collection in bpy.data.collections
        if collection.name.startswith("EXPORT_")
    ]


def objects_in_collection(collection):
    return [obj for obj in collection.objects if obj.type == "MESH"]

This lets a production file contain multiple delivery groups such as EXPORT_CharacterBody, EXPORT_Weapon, and EXPORT_Accessories. Blender’s collection exporter workflow can also store exporter settings in the .blend file, which is useful when an asset needs repeated delivery over multiple revisions.

06. Produce a Readable Report

The report should be clear enough for an artist, producer, or technical lead to act on without opening the script.

def run_preflight():
    depsgraph = bpy.context.evaluated_depsgraph_get()
    report = {"errors": [], "warnings": []}

    for obj in bpy.context.selected_objects:
        errors, warnings = validate_object(obj)
        report["errors"].extend(errors)
        report["warnings"].extend(warnings)
        report["errors"].extend(validate_evaluated_geometry(obj, depsgraph))

    report["errors"].extend(validate_image_paths())
    return report


def print_report(report):
    if report["errors"]:
        print("EXPORT HALTED: VALIDATION ERRORS")
        for error in report["errors"]:
            print(f"[ERROR] {error}")

    for warning in report["warnings"]:
        print(f"[WARN] {warning}")

    if not report["errors"]:
        print("VALIDATION PASSED: READY TO EXPORT")

For a real add-on, write the report as JSON or Markdown beside the exported files. Logs are part of the handoff.

07. Export Settings Are Part of the Asset

The same mesh can produce different results depending on axis conversion, scale, modifier settings, embedded texture options, animation flags, and batch mode.

Document the export preset:

• Blender version
• export format and version
• target application or engine
• axis settings
• unit scale behavior
• modifier application behavior
• smoothing and tangent settings
• animation, armature, and shape-key settings
• texture path behavior
• batch mode and output directory

Avoid treating experimental or risky settings as defaults. For example, some space-transform options are explicitly sharp-edged for armatures and animation. A production preset should be tested with the target import pipeline before it becomes standard.

08. When to Turn the Script Into an Add-On

A one-off script is fine for a single delivery. A repeatable pipeline tool should become a small Blender add-on when:

• multiple artists need the same checks
• export settings must be preserved between sessions
• the tool needs a UI, progress feedback, or persistent preferences
• validation needs to run from a menu or panel
• the team needs poll(), check(), and execute() behavior
• the tool should write reports into a predictable folder

Production value comes from repeatability. The script is not just an exporter; it is a shared contract between art, tech art, and integration.

If the same export mistake has been fixed twice, it belongs in validation. The goal is not to automate around weak source files; it is to make preventable delivery risk visible before the package leaves the DCC.