Strapi Cheat Sheet

Overview

Strapi is the leading open-source headless CMS built with Node.js. It provides an auto-generated REST and GraphQL API, a customizable admin panel for content editors, and a flexible plugin system. Strapi lets you define content types through the admin UI or code, and it automatically generates CRUD endpoints for each type.

Strapi supports PostgreSQL, MySQL, MariaDB, and SQLite as database backends. It includes a role-based access control system, media library with image optimization, internationalization (i18n), and webhook integrations. Content can be delivered to any frontend framework, mobile app, or IoT device through its API.

Installation

# Create a new Strapi project
npx create-strapi-app@latest my-project

# With specific database
npx create-strapi-app@latest my-project --dbclient=postgres

# Quick start with SQLite (no prompts)
npx create-strapi-app@latest my-project --quickstart

# Start development server
cd my-project
npm run develop

# Admin panel: http://localhost:1337/admin
# API: http://localhost:1337/api

Docker

# docker-compose.yml
version: "3"
services:
  strapi:
    image: strapi/strapi:latest
    environment:
      DATABASE_CLIENT: postgres
      DATABASE_HOST: db
      DATABASE_PORT: 5432
      DATABASE_NAME: strapi
      DATABASE_USERNAME: strapi
      DATABASE_PASSWORD: strapi
    ports:
      - "1337:1337"
    volumes:
      - ./app:/srv/app
    depends_on:
      - db
  db:
    image: postgres:16
    environment:
      POSTGRES_DB: strapi
      POSTGRES_USER: strapi
      POSTGRES_PASSWORD: strapi
    volumes:
      - pgdata:/var/lib/postgresql/data
volumes:
  pgdata:

Core Commands

Command	Description
`npm run develop`	Start in development mode with auto-reload
`npm run start`	Start in production mode
`npm run build`	Build the admin panel
`npm run strapi generate`	Generate components, APIs, plugins
`npm run strapi routes:list`	List all registered routes
`npm run strapi ts:generate-types`	Generate TypeScript types
`npm run strapi configuration:dump`	Export configuration
`npm run strapi configuration:restore`	Import configuration
`npm run strapi transfer`	Transfer data between instances

REST API

CRUD Operations

# List entries (with pagination)
curl "http://localhost:1337/api/articles?pagination[page]=1&pagination[pageSize]=25"

# Get single entry
curl "http://localhost:1337/api/articles/1"

# Create entry
curl -X POST "http://localhost:1337/api/articles" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer JWT_TOKEN" \
  -d '{"data":{"title":"New Article","content":"Article body","publishedAt":"2026-01-01T00:00:00.000Z"}}'

# Update entry
curl -X PUT "http://localhost:1337/api/articles/1" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer JWT_TOKEN" \
  -d '{"data":{"title":"Updated Title"}}'

# Delete entry
curl -X DELETE "http://localhost:1337/api/articles/1" \
  -H "Authorization: Bearer JWT_TOKEN"

Filtering and Population

# Filter results
curl "http://localhost:1337/api/articles?filters[title][$contains]=hello"

# Deep filtering
curl "http://localhost:1337/api/articles?filters[category][name][$eq]=tech"

# Populate relations
curl "http://localhost:1337/api/articles?populate=*"

# Nested population
curl "http://localhost:1337/api/articles?populate[author][populate]=avatar"

# Sort and pagination
curl "http://localhost:1337/api/articles?sort=createdAt:desc&pagination[page]=1&pagination[pageSize]=10"

# Select specific fields
curl "http://localhost:1337/api/articles?fields[0]=title&fields[1]=slug"

Filter Operators

Operator	Example	Description
`$eq`	`filters[status][$eq]=published`	Equal
`$ne`	`filters[status][$ne]=draft`	Not equal
`$lt` / `$lte`	`filters[price][$lt]=100`	Less than
`$gt` / `$gte`	`filters[price][$gt]=10`	Greater than
`$in`	`filters[status][$in][0]=published`	In array
`$notIn`	`filters[status][$notIn][0]=archived`	Not in array
`$contains`	`filters[title][$contains]=hello`	Contains substring
`$startsWith`	`filters[title][$startsWith]=How`	Starts with
`$null`	`filters[deletedAt][$null]=true`	Is null

Configuration

Database Configuration

// config/database.js
module.exports = ({ env }) => ({
  connection: {
    client: "postgres",
    connection: {
      host: env("DATABASE_HOST", "127.0.0.1"),
      port: env.int("DATABASE_PORT", 5432),
      database: env("DATABASE_NAME", "strapi"),
      user: env("DATABASE_USERNAME", "strapi"),
      password: env("DATABASE_PASSWORD", "strapi"),
      ssl: env.bool("DATABASE_SSL", false),
    },
  },
})

Server Configuration

// config/server.js
module.exports = ({ env }) => ({
  host: env("HOST", "0.0.0.0"),
  port: env.int("PORT", 1337),
  url: env("PUBLIC_URL", "http://localhost:1337"),
  app: {
    keys: env.array("APP_KEYS"),
  },
})

Plugin Configuration

// config/plugins.js
module.exports = ({ env }) => ({
  upload: {
    config: {
      provider: "aws-s3",
      providerOptions: {
        s3Options: {
          credentials: {
            accessKeyId: env("AWS_ACCESS_KEY_ID"),
            secretAccessKey: env("AWS_ACCESS_SECRET"),
          },
          region: env("AWS_REGION"),
          params: { Bucket: env("AWS_BUCKET") },
        },
      },
    },
  },
  email: {
    config: {
      provider: "sendgrid",
      providerOptions: {
        apiKey: env("SENDGRID_API_KEY"),
      },
      settings: {
        defaultFrom: "noreply@example.com",
        defaultReplyTo: "support@example.com",
      },
    },
  },
  graphql: {
    config: {
      defaultLimit: 25,
      maxLimit: 100,
    },
  },
})

Advanced Usage

Custom Controllers

// src/api/article/controllers/article.js
const { createCoreController } = require("@strapi/strapi").factories

module.exports = createCoreController("api::article.article", ({ strapi }) => ({
  async find(ctx) {
    const { data, meta } = await super.find(ctx)
    // Add custom logic
    return { data, meta }
  },

  async customAction(ctx) {
    const entries = await strapi.entityService.findMany("api::article.article", {
      filters: { publishedAt: { $notNull: true } },
      sort: { createdAt: "desc" },
      limit: 10,
    })
    return entries
  },
}))

Custom Routes

// src/api/article/routes/custom.js
module.exports = {
  routes: [
    {
      method: "GET",
      path: "/articles/featured",
      handler: "article.customAction",
      config: {
        auth: false,
      },
    },
  ],
}

Lifecycle Hooks

// src/api/article/content-types/article/lifecycles.js
module.exports = {
  async beforeCreate(event) {
    const { data } = event.params
    if (data.title) {
      data.slug = data.title.toLowerCase().replace(/\s+/g, "-")
    }
  },

  async afterCreate(event) {
    const { result } = event
    await strapi.service("api::notification.notification").send({
      message: `New article: ${result.title}`,
    })
  },
}

Webhooks

// Configure in Admin > Settings > Webhooks
// Or programmatically
// Triggers: entry.create, entry.update, entry.delete, entry.publish, entry.unpublish

Troubleshooting

Issue	Solution
Admin panel blank after build	Run `npm run build` to rebuild the admin; clear browser cache
Database connection refused	Verify database credentials and host; ensure DB service is running
API returning 403	Check permissions in Settings > Roles; enable public access for the endpoint
Slow API responses	Add indexes to database; use `populate` selectively instead of `populate=*`
Upload fails	Check file size limits in `config/plugins.js`; verify storage permissions
TypeScript types outdated	Run `npm run strapi ts:generate-types` after content type changes
Migration errors after upgrade	Back up database first; follow Strapi migration guides for version jumps
GraphQL not available	Install plugin: `npm run strapi install graphql`
i18n content missing	Enable i18n on the content type; create content for each locale