✨ We just launched Fimo.ai - an AI Website Builder to create websites in minutes - Try it now ✨

Back to integrations

Integrate Node.js with Strapi

Node.js brings JavaScript to the backend. Combined with Strapi, it’s a powerful way to build modern, scalable web applications

tweet selection
nodejs.svg

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

    What Is NodeJS?

    NodeJS is a server-side JavaScript runtime built on Chrome's V8 JavaScript engine. It uses an event-driven, non-blocking I/O model that makes it lightweight and efficient for building scalable network applications. By integrating NodeJS with Strapi, you can use JavaScript for both frontend and backend development, creating a unified language experience across the entire stack.

    Why Integrate NodeJS With Strapi

    By integrating NodeJS with Strapi, you leverage the benefits of using Node.js to create a powerful combination for developing flexible, scalable digital experiences. The Strapi 5 features bring enhanced performance and improved developer experience, including support for TypeScript in Strapi 5, while Strapi Cloud offers a fully managed solution that eliminates infrastructure headaches.

    Start with Strapi Cloud to experience the power when you integrate NodeJS with Strapi without infrastructure hassle.

    API Flexibility

    Strapi automatically creates RESTful APIs for each content type as soon as you define it, and will also create GraphQL APIs if the GraphQL plugin is installed. This GraphQL and REST integration means you can pick the right API style for your specific needs, cutting down development time and allowing for quick changes.

    This dual support lets teams use REST when they want simplicity, or GraphQL when they need precise data fetching—all from the same Strapi backend.

    Performance Benefits

    Strapi and NodeJS together boost performance through:

    1. Optimized data transfer: GraphQL fetches exactly what you need, avoiding the common problems of getting too much or too little data—especially important for mobile apps.
    2. Reduced backend overhead: Since APIs are generated automatically, you write less code, resulting in a cleaner, faster backend.
    3. For high-traffic sites, implementing API request throttling can further enhance performance.

    These performance gains really matter for high-traffic sites or content-heavy platforms where speed counts.

    Scalability Advantages

    Strapi's architecture, powered by NodeJS, makes scaling simple:

    • Horizontal scaling is achieved by adding more servers when you need to handle more users.
    • Additionally, you can add new features or content types without rebuilding everything, thanks to Strapi's flexible architecture.

    Effective content lifecycle management is also facilitated by Strapi's scalable architecture.

    Both REST and GraphQL APIs work independently, making your application easier to grow as your needs change.

    Customizability

    Strapi gives developers the flexibility they need:

    By leveraging the Strapi middleware architecture, you can add custom integrations tailored to your requirements. With Strapi CMS for NodeJS, developers can build unique solutions without being boxed in by the CMS.

    Integration Capabilities

    With its NodeJS foundation, Strapi plays nicely with:

    • Popular frontend frameworks (React, Vue, Angular)
    • Existing NodeJS services and microservices
    • Third-party tools and APIs

    As a headless CMS with Strapi, this compatibility makes development smoother and helps create more connected applications. For example, you can easily add Google Maps integration to your Strapi application, leveraging the benefits of headless CMS for flexible content delivery across multiple channels.

    By integrating NodeJS with Strapi, developers can create flexible, high-performance applications that scale and customize easily. Whether you're building a content-rich website, an eCommerce platform, or a multi-channel digital experience, this combination gives you the tools to bring your ideas to life.

    How to Integrate and Deploy Strapi With NodeJS

    Deploying Strapi on NodeJS isn't complicated, but it does require careful planning. Here's how to do it right.

    Prerequisites and Environment Setup

    Before starting, make sure you have:

    • Node.js (LTS versions 18, 20, or 22 only—odd-numbered releases like 19, 21 are not supported)
    • npm or yarn package manager
    • Git for version control
    • Python (not required for SQLite with Strapi)

    For your database, choose from PostgreSQL, MySQL, SQLite, or others based on how much you need to scale.

    Initial Project Setup

    To create a new Strapi project, run:

    npx create-strapi-app my-project --quickstart

    This command sets up a new Strapi project with default settings and starts the server. You'll be prompted to create your first administrator account through the admin panel.

    Configuration for Development and Production

    Good configuration makes deployment much easier:

    1. Set up environment variables in a .env file or your server configuration. Include database credentials, host settings, and other environment-specific options.
    2. Create production-specific configurations in config/env/production/ to override default settings.
    3. Example production configuration:
    module.exports = ({ env }) => ({
  host: env('HOST', '0.0.0.0'),
  port: env.int('PORT', 1337),
  // Add other production-specific settings
});

    Deployment Process to Integrate NodeJS With Strapi

    1/. Build the admin UI:

    npm run build

    2/. Start the server in production mode:

    NODE_ENV=production npm run start

    For better process management, consider using PM2:

    pm2 start npm --name strapi -- run start

    Depending on your needs, there are many Strapi deployment options available to help you deploy your application effectively.

    Add API Request to Strapi

    Once your Strapi application is deployed, you'll need to interact with it from your Node.js application. Here's how to make API requests to your Strapi backend:

    1/. Using Axios for REST API calls:

    const axios = require('axios');

// Fetching a list of products
async function getProducts() {
  try {
    const response = await axios.get('http://your-strapi-url/api/products');
    return response.data;
  } catch (error) {
    console.error('Error fetching products:', error);
    throw error;
  }
}

// Creating a new product
async function createProduct(productData, token) {
  try {
    const response = await axios.post('http://your-strapi-url/api/products', 
      { data: productData },
      {
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${token}`
        }
      }
    );
    return response.data;
  } catch (error) {
    console.error('Error creating product:', error);
    throw error;
  }
}

    2/. Using GraphQL with Strapi:

    const { request, gql } = require('graphql-request');

const query = gql`
  query {
    products {
      data {
        id
        attributes {
          name
          price
          description
        }
      }
    }
  }
`;

async function fetchProductsWithGraphQL() {
  try {
    const data = await request('http://your-strapi-url/graphql', query);
    return data.products;
  } catch (error) {
    console.error('Error fetching with GraphQL:', error);
    throw error;
  }
}

    Authentication

    Strapi uses JWT (JSON Web Tokens) for authentication. Here's how to implement authentication in your Node.js application:

    1/. User Registration:

    const axios = require('axios');

async function registerUser(userData) {
  try {
    const response = await axios.post('http://your-strapi-url/api/auth/local/register', {
      username: userData.username,
      email: userData.email,
      password: userData.password
    });
    
    return {
      user: response.data.user,
      jwt: response.data.jwt
    };
  } catch (error) {
    console.error('Registration error:', error.response?.data || error);
    throw error;
  }
}

    2/. User Login:

    async function loginUser(credentials) {
  try {
    const response = await axios.post('http://your-strapi-url/api/auth/local', {
      identifier: credentials.email, // can be email or username
      password: credentials.password
    });
    
    return {
      user: response.data.user,
      jwt: response.data.jwt
    };
  } catch (error) {
    console.error('Login error:', error.response?.data || error);
    throw error;
  }
}

    3/. Making Authenticated Requests:

    async function getUserProfile(userId, jwt) {
  try {
    const response = await axios.get(`http://your-strapi-url/api/users/${userId}`, {
      headers: {
        Authorization: `Bearer ${jwt}`
      }
    });
    
    return response.data;
  } catch (error) {
    console.error('Error fetching user profile:', error);
    throw error;
  }
}

    Populating Strapi with Data

    There are several approaches to populate your Strapi instance with initial data:

    1/. Using Strapi's Content API:

    const axios = require('axios');
const fs = require('fs');

async function seedData(jwt) {
  try {
    // Read seed data from JSON file
    const productsData = JSON.parse(fs.readFileSync('./seed-data/products.json', 'utf8'));
    
    // Create each product
    for (const product of productsData) {
      await axios.post('http://your-strapi-url/api/products', 
        { data: product },
        {
          headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${jwt}`
          }
        }
      );
      console.log(`Product ${product.name} created successfully`);
    }
    
    console.log('All seed data imported successfully');
  } catch (error) {
    console.error('Error seeding data:', error);
    throw error;
  }
}

    2/. Using Strapi's Seed Scripts:

    Create a seed script in your Strapi project:

    // scripts/seed.js
const fs = require('fs');
const path = require('path');

async function seedDatabase() {
  try {
    // Read seed data
    const categoriesData = JSON.parse(
      fs.readFileSync(path.resolve(__dirname, '../data/categories.json'), 'utf8')
    );
    const productsData = JSON.parse(
      fs.readFileSync(path.resolve(__dirname, '../data/products.json'), 'utf8')
    );
    
    // Create categories first
    for (const category of categoriesData) {
      await strapi.entityService.create('api::category.category', {
        data: category
      });
    }
    
    // Then create products with categories
    for (const product of productsData) {
      await strapi.entityService.create('api::product.product', {
        data: product
      });
    }
    
    console.log('Seed completed successfully');
  } catch (error) {
    console.error('Seed error:', error);
  }
}

module.exports = seedDatabase;

    Run the script with:

    NODE_ENV=development node -e "require('./scripts/seed.js')()"

    3/. Using Strapi's Database Lifecycles:

    For more advanced seeding, you can use Strapi's lifecycle hooks in your models:

    // api/product/models/product.js
module.exports = {
  lifecycles: {
    async beforeCreate(data) {
      // Modify data before creation
      if (data.autoGenerateSKU) {
        data.sku = `PRD-${Math.floor(Math.random() * 10000)}`;
      }
    },
    // Other lifecycle hooks
  },
};

    Project Example of Integrating NodeJS With Strapi (+ Github Project Repo)

    Let's explore how to combine Node.js with Strapi to build a dynamic product catalog for an e-commerce platform.

    Project Overview

    We're creating a flexible product catalog that's easy to manage through Strapi's admin interface and display on a React frontend. This setup uses Strapi for content management and Node.js for performance to deliver a fast, customizable solution.

    Implementation Highlights

    1. API Design: We're using both RESTful and GraphQL APIs to show off Strapi's flexibility. The REST API is used for standard operations, while GraphQL tackles complex queries and real-time updates.
    2. Custom Fields: We've created custom fields for our product model, including options for variations like size and color.
    3. Media Management: We're using Strapi's built-in media library to handle product images efficiently.
    4. Node.js Backend Integration: We've added custom middleware to handle inventory checks and price calculations.
    5. React Frontend: A simple React app displays products by pulling data from the Strapi API.

    Code Examples

    Here's how we define our product model in Strapi:

    // api/product/models/product.js
module.exports = {
  attributes: {
    name: {
      type: 'string',
      required: true
    },
    description: {
      type: 'richtext'
    },
    price: {
      type: 'decimal',
      required: true
    },
    category: {
      model: 'category'
    },
    images: {
      collection: 'file',
      via: 'related',
      allowedTypes: ['images'],
      plugin: 'upload',
      required: false
    },
    variations: {
      type: 'json'
    }
  }
};

    And here's an example of a custom middleware for inventory checking:

    // middleware/inventoryCheck.js
module.exports = (strapi) => {
  return {
    initialize() {
      strapi.app.use(async (ctx, next) => {
        await next();
        if (ctx.method === 'GET' && ctx.url.startsWith('/products')) {
          const products = ctx.body.data || ctx.body;
          for (let product of products) {
            product.inStock = await checkInventory(product.id);
          }
        }
      });
    },
  };
};

async function checkInventory(productId) {
  // Implement inventory check logic here
  return true; // Placeholder
}

    Note: The provided code for inventoryCheck.js needs to be updated to match Strapi's middleware structure. It should export a middleware function directly and be registered in the middleware configuration files for proper functionality.

    Results and Benefits

    By integrating NodeJS with Strapi for our product catalog, we've achieved:

    1. Improved Performance: Strapi's efficient content delivery and NodeJS's non-blocking I/O create faster response times, even under heavy load.
    2. Scalability: Our setup allows for easy horizontal scaling, with Strapi handling content and NodeJS managing business logic.
    3. Flexibility: Using both REST and GraphQL APIs gives us options for different frontend needs and third-party connections.
    4. Customization: We've extended Strapi's core functionality with custom middleware to fit specific business needs.

    GitHub Repository

    Check out the complete project on GitHub: Strapi-NodeJS Product Catalog

    The repository includes:

    • Strapi configuration files
    • Custom API endpoints and middleware
    • React frontend code
    • Detailed setup instructions

    This example shows how integrating NodeJS with Strapi creates a powerful backend for modern web applications. By using Strapi's content management and extending it with custom Node.js code, developers can quickly build scalable applications that handle complex business needs.

    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 at 12:30 pm – 1:30 pm CST.

    For more details, visit the Strapi documentation and Node.js documentation.

    tweet selection