N8n Validation Expert

N8n Validation Expert is a community skill for implementing data validation within n8n workflows, covering input validation rules, schema enforcement, type checking, error routing, and data quality assurance for automated process reliability.

What Is This?

Overview

N8n Validation Expert provides tools for ensuring data quality within n8n workflow pipelines. It covers input validation that checks incoming data against defined constraints, schema enforcement that verifies structures match expected formats using JSON Schema, type checking that confirms field values are correct types before operations use them, error routing that directs invalid items to separate paths for review, and data quality assurance that applies completeness checks before final output. The skill enables users to build workflows that handle bad data gracefully.

Who Should Use This

This skill serves workflow developers building reliable n8n automation pipelines, data engineers implementing validation gates in integration workflows, and operations teams preventing bad data from propagating through automated processes.

Why Use It?

Problems It Solves

Workflows processing unvalidated input encounter runtime errors when fields are missing or contain unexpected values. Inconsistent API responses cause downstream nodes to fail on missing properties. Invalid data passing through workflows contaminates destination systems with malformed records. Manual quality checks do not scale as volume increases.

Core Highlights

Input validator checks field presence, format, and value constraints on incoming data items. Schema enforcer verifies data structures against JSON Schema definitions at validation checkpoints. Type checker confirms value types match expected formats before processing continues. Error router separates valid and invalid items into distinct processing paths.

How to Use It?

Basic Usage

// n8n validation function
// In a Function node
const validated = [];
const rejected = [];

for (const item
  of $input.all()) {
  const d = item.json;
  const errors = [];

  // Required fields
  if (!d.email) {
    errors.push(
      'Missing email');
  }
  if (!d.name) {
    errors.push(
      'Missing name');
  }

  // Format checks
  const emailRe =
    /^[^@]+@[^@]+\.[^@]+$/;
  if (d.email
    && !emailRe.test(
      d.email)) {
    errors.push(
      'Invalid email');
  }

  // Type checks
  if (d.age
    && typeof d.age
      !== 'number') {
    errors.push(
      'Age not number');
  }

  // Range checks
  if (d.age
    && (d.age < 0
      || d.age > 150)) {
    errors.push(
      'Age out of range');
  }

  if (errors.length === 0) {
    validated.push({
      json: d });
  } else {
    rejected.push({
      json: {
        ...d,
        _errors: errors
      }
    });
  }
}

return [
  validated, rejected];

Real-World Examples

// Schema validation
const Ajv = require('ajv');
const ajv = new Ajv();

const schema = {
  type: 'object',
  required: [
    'id', 'email',
    'amount'],
  properties: {
    id: {
      type: 'string',
      pattern:
        '^[A-Z]{2}[0-9]+$'
    },
    email: {
      type: 'string',
      format: 'email'
    },
    amount: {
      type: 'number',
      minimum: 0,
      maximum: 100000
    },
    status: {
      type: 'string',
      enum: [
        'active',
        'pending',
        'closed']
    },
    tags: {
      type: 'array',
      items: {
        type: 'string' },
      maxItems: 10
    }
  }
};

const validate =
  ajv.compile(schema);
const valid = [];
const invalid = [];

for (const item
  of $input.all()) {
  if (validate(
    item.json)) {
    valid.push(item);
  } else {
    invalid.push({
      json: {
        ...item.json,
        _errors:
          validate.errors
      }
    });
  }
}

return [valid, invalid];

Advanced Tips

Place validation immediately after entry points such as webhooks and API responses to catch problems early. Use the IF node after validation to split valid and invalid items into separate branches. Collect validation statistics to identify recurring quality issues from specific sources.

When to Use It?

Use Cases

Validate webhook payload fields before processing customer orders in a fulfillment workflow. Enforce data schema on API responses before writing records to a database destination node. Route invalid records to a notification channel while continuing to process valid items in the main workflow path.

Related Topics

n8n workflows, data validation, JSON Schema, workflow automation, data quality, error handling, and input sanitization.

Important Notes

Requirements

n8n workflow platform with Function node access for custom validation logic. JSON Schema library such as Ajv if using schema-based validation within code nodes. Defined data contracts for each workflow entry point specifying expected fields and types.

Usage Recommendations

Do: validate data at every boundary where external data enters including webhooks, API calls, and file imports. Log rejected items with error messages to enable source systems to fix quality issues. Define validation schemas as reusable templates across workflows that process similar structures.

Don't: validate only at workflow end since invalid data may have caused side effects in earlier nodes. Silently drop invalid records without logging since this makes debugging gaps difficult. Apply strict validation to optional fields that may legitimately be absent.

Limitations

Custom validation in Function nodes requires JavaScript knowledge that may exceed no-code builders skill level. Schema validation libraries must be available in the n8n execution environment which depends on installation settings. Cross-field validation rules that depend on external lookups add latency to workflow execution.