flowable/flowable-engine · error · FlowableException

Unsupported IO parameter type '

Error message

Unsupported IO parameter type '

What it means

Flowable's DefaultVariableValueConversionHandler converts raw IO parameter values into typed engine variables based on a declared type name (string, integer, long, double, boolean, date, localdate, json, array, etc.). When convertValue is given a type name that is not one of the known switch cases, it throws this FlowableException because it has no conversion strategy for that type. It signals a mismatch between the declared IO parameter type in the process/model definition and the set of types this handler supports.

Source

Thrown at modules/flowable-engine-common/src/main/java/org/flowable/common/engine/impl/DefaultVariableValueConversionHandler.java:49

 * Default implementation of {@link VariableValueConversionHandler}.
 *
 * @author Tijs Rademakers
 */
public class DefaultVariableValueConversionHandler implements VariableValueConversionHandler {

    @Override
    public Object convertValue(Object value, String type, VariableJsonMapper variableJsonMapper) {
        return switch (type.toLowerCase()) {
            case "string" -> convertToString(value);
            case "integer", "int" -> convertToInteger(value);
            case "long" -> convertToLong(value);
            case "double" -> convertToDouble(value);
            case "boolean" -> convertToBoolean(value);
            case "date" -> convertToDate(value);
            case "localdate" -> convertToLocalDate(value);
            case "json" -> convertToJson(value, variableJsonMapper);
            case "array" -> convertToArray(value, variableJsonMapper);
            default -> throw new FlowableException("Unsupported IO parameter type '" + type + "'");
        };
    }

    protected String convertToString(Object value) {
        if (value instanceof String stringValue) {
            return stringValue;
        }
        if (value != null && JsonUtil.isJsonNode(value)) {
            FlowableJsonNode jsonNode = JsonUtil.asFlowableJsonNode(value);
            if (jsonNode.isString()) {
                return jsonNode.asString();
            }
            return jsonNode.toString();
        }
        return value.toString();
    }

    protected Integer convertToInteger(Object value) {

View on GitHub (pinned to d6d39ce1c6)

Solutions

1. Check the declared IO parameter type string in the model and correct it to a supported value: string, integer, long, double, boolean, date, localdate, json, array.
2. Register a custom VariableValueConversionHandler (via the process engine configuration) that handles the missing type name in an overridden convertValue.
3. Verify the Flowable version matches the model's expected feature set; upgrade the engine if the type was introduced later.
4. Log/inspect the actual 'type' value at runtime to spot whitespace or case differences (the switch is lowercase-sensitive).

Example fix

// before (model)
<ioParameter source="count" target="count" type="int"/>
// after
<ioParameter source="count" target="count" type="integer"/>

java.util.Set<String> SUPPORTED = java.util.Set.of("string","integer","long","double","boolean","date","localdate","json","array");
if (!SUPPORTED.contains(declaredType)) {
    throw new IllegalArgumentException("IO parameter type not supported by this handler: " + declaredType);
}

boolean isSupportedIoType(Object type) {
    return type instanceof String t && java.util.Set.of("string","integer","long","double","boolean","date","localdate","json","array").contains(t);
}

try {
    Object converted = conversionHandler.convertValue(rawValue, declaredType, jsonMapper);
} catch (FlowableException e) {
    if (e.getMessage().startsWith("Unsupported IO parameter type")) {
        // log declaredType, fall back to raw value or fail fast with a clear model error
    } else throw e;
}

When it happens

Trigger: Calling convertValue (directly or via process/CaseTask IO parameter binding) with a declared parameter type such as 'int', 'number', 'datetime', 'string[]', or a custom/typo'd type like 'strin'. Also occurs when a newer model uses a type name added only in a newer Flowable version while an older handler is on the classpath.

Common situations: Typos in BPMN/CMMN ioParameter attribute values; copying type names from another engine or from JSON schema terminology (e.g. 'number' instead of 'double'); custom converters expected but the default DefaultVariableValueConversionHandler is installed instead of a custom subclass.

Understand the failure class

Background: Invalid enum value errors: "Unknown type", "Invalid scope", "must be one of" — when a string is not on the library's allowed list — this error's family across 23 libraries.

Related errors

• Cannot convert value of type
• JSON string does not represent an object:
• JSON string does not represent an array:
• unsupported variable scope type:
• Error while executing transformation from object: using tra

AI-assisted analysis of flowable/flowable-engine@d6d39ce1c6 (2026-09-11). Data as JSON: /api/errors/9d9be1f4231ec170. Report an issue: GitHub.