Getting started

Your first run

You can complete this path in one sitting. The examples use a main space and an en locale, which are the defaults for many new workspaces.

Sign in and choose Create Organization from your account page. Give the organization a name and choose its default locale. The default locale is the language Blobify selects when you create your first entry, and you can add more locales later in Settings.

An organization is the workspace boundary for members, schemas, spaces, storage settings, and generated code. Keep the first run simple and use the main space created with the organization.

Open Settings > Storage and choose Set up with wizard. Amazon S3 and Cloudflare R2 both work. The wizard collects the bucket connection, tests it, and saves the configuration. Follow its browser access instructions too, since the dashboard and a public site need permission to read bucket objects.

If your bucket is private, your site can still read it from server-side code with credentials or signed requests. Blobify remains outside the content read path in either mode. See How Blobify works for the draft, publish, summary, routing, and asset model.

Open Schema, create a model named Article with the id article, then add title, slug, and body. This is the smallest useful editorial model for the rest of this guide:

{
  "title": { "type": "text", "required": true, "translatable": true },
  "slug": { "type": "slug", "required": true, "sourceField": "title" },
  "body": { "type": "richtext", "translatable": true }
}

Use title as the display field and include title and slug in the model's summary fields. That keeps article lists useful and lets the generated client find an article by its slug. The slug field can derive its value from the title, while the rich text field stores the article body as a structured AST. See Models and blocks for the full schema shape and when to introduce reusable blocks.

Open Content, choose Create Content, and select the Article model. Enter a title such as Hello world, confirm the generated slug is hello-world, and add a short paragraph to the body. Select Save before publishing.

Saving writes a mutable draft.json document into your bucket. Localized values such as the English title and body are stored under en, while the non-localized slug is stored once. Content JSON documents the complete draft and published shapes.

Select Publish, choose the en locale, and confirm. Blobify writes the consumer-facing published.json snapshot and queues reconciliation of the article model's published summary artifacts.

The draft remains editable after publishing. A later save changes only the draft; publish again when those changes are ready for your site. Published documents contain only published locales and omit dashboard-only actor details.

For a public bucket, every read is a normal HTTP request. Once reconciliation completes, the summary manifest points to immutable, versioned shard files, and a full content document lives beside its draft. This minimal example reads both:

const bucket = "https://cdn.example.com";

const manifest = await fetch(
  `${bucket}/spaces/main/summaries/published/index.json`,
).then((response) => response.json());

const shardKeys = Object.values(manifest.models.article.shards) as string[];
const shards = await Promise.all(
  shardKeys.map((key) =>
    fetch(`${bucket}/spaces/main/summaries/published/article/${key}`)
      .then((response) => response.json()),
  ),
);
const articleSummaries = shards.flatMap((shard) => shard.items);

const contentId = articleSummaries[0].id;
const article = await fetch(
  `${bucket}/spaces/main/content/article/${contentId}/published.json`,
).then((response) => response.json());

These paths assume the organization has no root prefix or per-space content prefix. If you configured either one, it becomes part of the object path. The generated client bakes those settings into its configuration and handles summary shards, content documents, references, and asset metadata for you.

Generate that client from Settings > Developer, under Developer Tools > SDK Generator, then add the downloaded file to your application:

import { createClient } from "./blobify";

const cms = createClient({
  baseUrl: "https://cdn.example.com",
  spaceId: "main",
  state: "published",
});

const articles = await cms.getAll("article", "en");
const article = await cms.findOne(
  "article",
  { slug: "hello-world" },
  "en",
);

getAll returns the model's entries for a locale. findOne matches the supplied summary fields, so the slug summary field configured above makes the second read work. Regenerate the client after schema changes so its TypeScript types stay in sync.

Or start from a preset

If you want a useful schema before designing your own, open Schema > Import and stay on the Presets tab. Choose Blog, Simple Website, Journal, or Status Page, review the included models and blocks, then import the bundle. A preset is the fastest path to a working schema, and you can edit every imported model afterward.

Connect an AI agent (optional)

Blobify includes an MCP server for AI-assisted authoring. Connect Claude or ChatGPT through Blobify's OAuth flow, then choose and approve the organizations you want to share. Hosts that accept bearer headers can connect with a scoped API key instead. Follow the MCP server guide for host-specific setup.

For scripts, migrations, and CI, create a scoped key under Settings > Developer > API Keys. The Automation API covers reading context, validating payloads, saving drafts, and publishing without using the dashboard.

Where to go next