Integrate AirOps with Strapi

These integration guides are not official documentation and the Strapi Support Team will not provide assistance with them.

What Is AirOps?

AirOps is a workflow automation platform built around AI-powered content operations. At its core, it's a visual workflow builder that connects data sources, AI models, and external APIs, including content management systems like Strapi.

The platform provides workflow step categories including AI operations, code execution, conditional logic, data transformations, and CMS integrations. Workflows accept inputs, process data through chained steps with variable management, and output structured results.

Common patterns include content enrichment, multi-step validation pipelines, and scheduled batch processing across integrated systems.

Why Integrate AirOps with Strapi

Consider this integration when manual content operations become a bottleneck. If you're writing meta descriptions for thousands of pages, manually entering content from external sources, or running repetitive updates across your content library, this integration can save time. Automated generation with review gates cuts your time investment while maintaining quality standards.

The technical benefit: elimination of custom integration code. Strapi exposes its content through REST and GraphQL APIs, and AirOps provides built-in API request steps with authentication, retry logic, and error handling already configured. Here's what this connection provides:

• Direct API connection with authentication tokens you generate in both platforms
• Built-in retry logic that handles rate limits and temporary failures automatically
• Variable management for passing data between workflow steps without custom code
• Error handling that captures and logs failures for debugging

These capabilities work together to eliminate the maintenance overhead of custom integrations. You generate an API token in Strapi, paste it into AirOps integration settings, and you're connected. No middleware or maintenance overhead. You skip building retry logic, handling rate limits, or debugging webhook failures.

For AI-powered operations, the workflow architecture gives you granular control over content generation. You can query Strapi for existing content, pass it through AI models for optimization or transformation, apply custom data formatting in code steps, and write results back to specific content types. SEO optimization passes updating meta tags across entire content libraries work this way in production environments.

How to Integrate AirOps with Strapi

The integration follows a direct API connection pattern: you can generate authentication tokens in both platforms, configure API request steps in AirOps workflows pointing to Strapi endpoints, and handle JSON responses. You configure authentication once, then reuse the connection across multiple workflows without additional setup.

Prerequisites

Install Node.js requirements (LTS version 18, 20, or 22) and npm 6 or above. Verify with node --version and npm --version before proceeding.

If you don't have a Strapi project running, consider initializing one:

1npx create-strapi@latest

For AirOps integration capabilities with Strapi, first install the SDK using npm:

1npm install @airops/airops-js

You'll need two credentials: your AirOps Workspace ID and API Key (both available in AirOps Workspace Settings). On the Strapi side, you need to generate an API token with full-access permissions and unlimited duration.

Connecting AirOps to Strapi API

In your Strapi Admin Panel, navigate to Settings → Global settings → API Tokens and create a new token. It helps to set the access level to "Full access" and duration to "Unlimited" for persistent workflow connections.

Strapi generates REST endpoints following /api/{content-type} patterns. In AirOps, consider adding an API step to your workflow and configuring the connection. Set the HTTP method (GET, POST, PUT, DELETE) and add authentication headers:

1{
2  "Authorization": "Bearer YOUR_STRAPI_API_TOKEN",
3  "Content-Type": "application/json"
4}

You can configure the request URL and wrap POST data in a data object as required by Strapi's REST API. It helps to test the connection with a simple GET request to verify that authentication works.

Building Content Generation Workflows

Workflows follow a modular architecture where inputs define parameters, processing steps transform data, and outputs return results.

Configure workflow inputs that match your Strapi content type schema. For processing, consider adding these step types:

• Web research steps for gathering data from external sources
• LLM prompts for content generation and optimization
• Transformation steps to match Strapi's structure and field requirements
• Validation steps to ensure content meets quality thresholds

These steps work together to transform raw inputs into structured content ready for your CMS.

The API call step integrates with Strapi by configuring the HTTP method, authentication headers with Bearer token authentication, and the target endpoint URL. You can map workflow variables to Strapi content type fields using Liquid template syntax (e.g., {{ step_2.output.title }}). Leaving the publishedAt field unset creates draft content in Strapi, enabling manual review before publication; setting it to a future date does not create a draft.

It helps to test workflows thoroughly before production deployment. Check API responses for appropriate status codes and validate that content appears in Strapi with proper formatting.

Configuring Human Review Checkpoints

Human review steps create approval gates in your workflow. When execution reaches a review checkpoint, it pauses automatically and creates a review session accessible via the interface or History tab, waiting for explicit manual approval or cancellation.

Consider adding a Flow step to your workflow and selecting "Human Review." You can label the content item requiring validation and assign its value using Liquid syntax: {{step_3.output}}. For reviewing multiple items simultaneously, consider adding distinct labels for each. Review sessions persist in your workflow history, allowing you to approve content batches asynchronously rather than in real-time.

You can implement conditional branching after review steps using Condition Steps to evaluate the review status. If approved, route to Strapi publishing API calls. If rejected, route to logging, error handlers, or revision workflows. This ensures rejected content never reaches production. It helps to configure review routing and notifications based on your team's approval workflow.

Running Batch Operations

Batch processing happens through the Grid interface. Navigate to your workflow and select "Run in Bulk." Upload a CSV file with input data (each row becomes one workflow execution). Map CSV columns to workflow inputs, and AirOps processes all rows with real-time progress tracking.

The Grid interface displays individual item status with these categories:

• In-progress items show active processing with step-by-step updates
• Success items display completion time and generated content
• Failed items include error details for debugging and resolution

You can export results and re-run workflows for specific failed rows, giving you granular control over batch operations.

Consider starting with smaller batch sizes. Ten to 50 items work well for testing. Monitor API response times and error rates, and verify content appears correctly in Strapi before scaling to hundreds or thousands of items.

Project Example: Build an SEO Content Hub

This workflow demonstrates content generation with metadata optimization, human review gates, and automated publishing.

You can configure your Strapi content type with SEO fields: title (60 chars), metaDescription (155 chars), slug, robots, and canonicalUrl.

Using the API token from prerequisites, consider designing a workflow with inputs for keyword, topic, and word count, then add AI generation and metadata steps.

Configure the Strapi API integration step with POST method, authentication headers, and request body structure:

1{
2  "data": {
3    "title": "{{ step_2.output.title }}",
4    "slug": "{{ step_2.output.slug }}",
5    "metaTitle": "{{ step_3.output.metaTitle }}",
6    "metaDescription": "{{ step_3.output.metaDescription }}",
7    "content": "{{ step_4.output.content }}",
8    "publishedAt": null
9  }
10}

Consider adding a human review checkpoint after content creation but before publishing. You can configure conditional logic: approved content routes to a Strapi API call setting the entry to published state; rejected content routes to error logging or revision workflows.

For batch operations with Strapi, use supported plugins or custom integrations to import content in bulk (e.g., via CSV), which will appear in Strapi as drafts ready for review. Monitor status according to your integration's capabilities.

For scale, consider implementing Redis caching and database indexing on queried fields. Monitor your Strapi server's response times during initial batches. If you see timeouts, reduce the batch size incrementally. It helps to set up webhooks for entry publish events to trigger downstream operations like sitemap regeneration or CDN cache invalidation.

Strapi Open Office Hours

If you have any questions about Strapi 5 or just would like to stop by and say hi, you can join us at Strapi's Discord Open Office Hours, Monday through Friday, from 12:30 pm to 1:30 pm CST: Strapi Discord Open Office Hours.

For more details, visit the Strapi documentation and AirOps documentation.