Migrate from Strapi to MeshBase

Switch from self-hosted Strapi complexity to MeshBase simplicity. This guide covers exporting your Strapi content and importing it to MeshBase.

Why Switch from Strapi?

🚫No Server Management

Strapi requires hosting, updates, security patches. MeshBase is fully managed - we handle infrastructure.

⚡Better Performance

MeshBase API is faster. No database queries to optimize, no server to scale.

🔒Security Included

No need to secure your own server. MeshBase handles authentication, rate limiting, and DDoS protection.

💰Lower Total Cost

When you factor in hosting, maintenance, and developer time, MeshBase is more cost-effective.

Migration Steps

Export from Strapi

Use Strapi's export plugin or database export

Transform Schemas

Convert Strapi content types to MeshBase format

Import to MeshBase

Use MeshBase API to create content and entries

Export from Strapi

Option 1: Export Plugin

npm install strapi-plugin-import-export-entries
# Configure in Strapi admin, then export your content

Option 2: Database Export

For PostgreSQL/MySQL:

# PostgreSQL
pg_dump strapi_db > strapi_export.sql

# MySQL
mysqldump -u user -p strapi_db > strapi_export.sql

Option 3: API Export Script

// export-strapi.js
const axios = require('axios');
const fs = require('fs');

async function exportStrapi() {
  const types = ['articles', 'pages', 'products']; // Your content types
  const data = {};
  
  for (const type of types) {
    const response = await axios.get(`http://localhost:1337/api/${type}`, {
      headers: { Authorization: `Bearer YOUR_TOKEN` }
    });
    data[type] = response.data.data;
  }
  
  fs.writeFileSync('strapi-export.json', JSON.stringify(data, null, 2));
  console.log('✅ Strapi data exported!');
}

exportStrapi();

Transform to MeshBase Format

// transform.js
const fs = require('fs');
const strapiData = JSON.parse(fs.readFileSync('strapi-export.json', 'utf8'));

const meshbaseData = {};

// Transform each content type
for (const [contentType, entries] of Object.entries(strapiData)) {
  meshbaseData[contentType] = entries.map(entry => {
    const { id, attributes, ...rest } = entry;
    
    // Flatten Strapi's nested structure
    return {
      ...attributes,
      // Handle relations
      ...transformRelations(attributes),
      // Handle media
      ...transformMedia(attributes)
    };
  });
}

function transformRelations(attrs) {
  const result = {};
  for (const [key, value] of Object.entries(attrs)) {
    if (value?.data) {
      // Strapi relation format
      result[key] = Array.isArray(value.data) 
        ? value.data.map(r => r.id)
        : value.data.id;
    }
  }
  return result;
}

function transformMedia(attrs) {
  const result = {};
  for (const [key, value] of Object.entries(attrs)) {
    if (value?.data?.attributes?.url) {
      // Strapi media format - you'll need to upload these to MeshBase
      result[key] = value.data.attributes.url;
    }
  }
  return result;
}

fs.writeFileSync('meshbase-import.json', JSON.stringify(meshbaseData, null, 2));
console.log('✅ Data transformed for MeshBase!');

Import to MeshBase

Create content types

First, create matching content types in MeshBase dashboard or via API.

Import entries

// import-to-meshbase.js
const data = require('./meshbase-import.json');

const API_URL = 'https://api.meshbase.io/v1';
const API_KEY = 'your-admin-key';

async function importToMeshBase() {
  for (const [contentType, entries] of Object.entries(data)) {
    console.log(`Importing ${entries.length} ${contentType}...`);
    
    for (const entry of entries) {
      await fetch(`${API_URL}/${contentType}`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${API_KEY}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(entry)
      });
    }
  }
  console.log('✅ Import complete!');
}

importToMeshBase();

Field Type Mapping

Strapi	MeshBase
`string`	`text`
`text`	`richtext`
`richtext`	`richtext`
`number`	`number`
`date/datetime`	`datetime`
`boolean`	`boolean`
`media`	`media`
`relation`	`relation`
`json`	`json`

After Migration

🎉

Migration Complete!

Once migrated, you can decommission your Strapi server and save on hosting costs. No more server maintenance!

→Update API endpoints in your application
→Test all content displays correctly
→Set up MeshBase webhooks for deployments
→Shut down Strapi server and celebrate! 🎊