---
title: "Export WordPress Posts to JSON for a Headless Front End (Astro, Next.js)"
url: "https://wpimportexport.com/export-wordpress-json-headless-astro-nextjs/"
description: "Export WordPress posts to a JSON file with your own keys and build a static Astro or Next.js blog from it, without the REST API or a running WordPress."
type: post
published: 2026-11-15T15:00:00+00:00
modified: 2026-11-14T10:44:58+00:00
categories: ["Export Guides", "Tutorials"]
tags: ["Import Export by RockStarLab"]
docs_topics: ["Export guides"]
---

# Export WordPress Posts to JSON for a Headless Front End (Astro, Next.js)

A headless front end built with Astro, Next.js or another static site generator needs your WordPress posts as data. The usual route is the WordPress REST API or WPGraphQL, which means the WordPress site has to be online and reachable every time the front end builds. For a blog that changes a few times a month, a JSON file is simpler: export the posts once, commit the file to the front end’s repository, and build from it. With [Import Export by RockStarLab](https://wordpress.org/plugins/import-export-by-rockstarlab/), you choose the posts and fields and name the JSON keys the way your front end expects. The example is a small Astro blog built from a coffee roastery’s journal.

**Free:** JSON export of posts and pages with your own key names. **PRO:** the same for custom post types and WooCommerce products.

## Short Answer

1. In **Export**, choose Posts and filter to the posts the front end should show, for example one category and Status `publish`.
2. Add Slug, Title, Date, Excerpt, Content, Featured Image URL, Featured Image Alt and Category Names, and rename each with the pencil icon to the key your front end uses.
3. Choose **JSON**, download the file and load it in the front end: in Astro with the `file()` loader of a content collection.

## Choose the posts

Our front end shows the roastery’s Journal category. A **Taxonomy Filter** on `category` with the condition **Has Term(s) – IN** selects those posts:

![Export filter: Taxonomy Filter, taxonomy category, condition Has Term(s) - IN, term journal-headless; total items available 4](https://wpimportexport.com/wp-content/uploads/2026/11/01-category-filter.webp)

_Only the posts in the Journal category go to the front end._

If the category could contain drafts, add a **Status** filter **Equals** `publish`; the export includes every status otherwise.

## Name the JSON keys

Each column becomes a key in every JSON object. Rename the columns to short, code-friendly names:

![Export File Structure with eight columns renamed: slug (post_name), title (post_title), date (post_date), excerpt (post_excerpt), content (post_content), image (featured_image_url), imageAlt (featured_image_alt), categories (category_names)](https://wpimportexport.com/wp-content/uploads/2026/11/02-json-keys-scaled.webp)

_The column names become the JSON keys your front end reads._

- **Slug** (`post_name`) → `slug`: the URL of each page on the front end.
- **Title** → `title`, **Date** → `date`, **Excerpt** → `excerpt`.
- **Content** → `content`: the post’s HTML, ready to render.
- **Featured Image URL** → `image` and **Featured Image Alt** → `imageAlt`.
- **Category Names** → `categories`.

Use names without spaces or dashes, so they work as property names in JavaScript.

## Export as JSON

On the next step, choose **JSON**. **Pretty Print** is on by default and keeps the file readable in code review. Name the file `posts` and start the export.

![Export Completed Successfully screen with Items Exported, File Size and Duration and a Download Export File button](https://wpimportexport.com/wp-content/uploads/2026/11/03-export-complete-3.webp)

_Download posts.json and put it in the front end's project._

The file is an array with one object per post:

```
[
    {
        "slug": "how-we-source-green-coffee",
        "title": "How We Source Green Coffee",
        "date": "2026-10-14 09:00:00",
        "excerpt": "Direct trade, fair prices and long relationships.",
        "content": "<!-- wp:paragraph -->\n<p>Intro paragraph for how we source green coffee.</p>\n<!-- /wp:paragraph -->\n\n…",
        "image": "https://www.example-roastery.com/wp-content/uploads/2026/11/farm-visit.jpg",
        "imageAlt": "",
        "categories": "Journal"
    },
    …
]
```

Things to know about the values:

- `content` is the HTML stored in WordPress, including the block comments such as `<!-- wp:paragraph -->`. Browsers ignore them, so you can render the HTML as it is.
- Images inside the content and in `image` still point to your WordPress uploads folder. Keep the WordPress site online for the images, or copy the uploads to the front end and replace the domain.
- `date` is in WordPress’s format and your site’s time zone.
- `imageAlt` is empty when the image has no alt text in the Media Library; give your template a fallback.

## Build an Astro blog from the file

We put the file in `src/data/posts.json` of a new Astro 5 project. A content collection loads it with the `file()` loader and uses the slug as each entry’s ID:

```
import { defineCollection, z } from 'astro:content';
import { file } from 'astro/loaders';

const posts = defineCollection({
  // posts.json is the file exported from WordPress
  loader: file('src/data/posts.json', {
    parser: (text) => JSON.parse(text).map((post) => ({ id: post.slug, ...post })),
  }),
  schema: z.object({
    slug: z.string(),
    title: z.string(),
    date: z.coerce.date(),
    excerpt: z.string(),
    content: z.string(),
    image: z.string(),
    imageAlt: z.string(),
    categories: z.string(),
  }),
});

export const collections = { posts };
```

A dynamic route creates one page per post, `src/pages/blog/[slug].astro`:

```
---
import { getCollection } from 'astro:content';
export async function getStaticPaths() {
  const posts = await getCollection('posts');
  return posts.map((post) => ({ params: { slug: post.id }, props: { post } }));
}
const { post } = Astro.props;
---
<article>
  <h1>{post.data.title}</h1>
  <time datetime={post.data.date.toISOString()}>{post.data.date.toDateString()}</time>
  {post.data.image && <img src={post.data.image} alt={post.data.imageAlt || post.data.title} />}
  <Fragment set:html={post.data.content} />
</article>
```

Together with a simple list page, the build produced a page for each of the four posts, named after their WordPress slugs:

```
$ npm run build
 generating static routes
▶ src/pages/blog/[slug].astro
  ├─ /blog/how-we-source-green-coffee/index.html
  ├─ /blog/five-single-origin-coffees-to-try-this-winter/index.html
  ├─ /blog/meet-the-team-behind-the-beans/index.html
  └─ /blog/our-new-roastery-opens-in-march/index.html
▶ src/pages/blog/index.astro
  └─ /blog/index.html
[build] 5 page(s) built in 638ms
```

In Next.js, import the same file in your page and return the slugs from `generateStaticParams`. Any tool that reads JSON can use it the same way.

## Keeping the front end up to date

When you publish or edit posts, run the same export again and replace the file. To export only what changed since the last run, see [incremental exports](https://wpimportexport.com/incremental-wordpress-export-changed-since-last-time/). If the site changes several times a day, the REST API is the better source; a JSON file suits a front end that is rebuilt on purpose.

## Before you switch

An export only reads your content. If you clean up slugs, excerpts or alt text before the export, for example by import, [back up the site](https://wpimportexport.com/how-to-create-a-wordpress-website-backup-and-restore-it/) first.

## With an AI agent

An AI agent connected through the WordPress MCP Adapter (see [connecting Claude Code to WordPress](https://wpimportexport.com/connect-claude-code-to-wordpress-mcp/)) can refresh the file for you, for example from the front end’s repository in Claude Code:

```
Export the published posts in Journal to posts.json with the keys slug, title, date, excerpt, content, image, imageAlt and categories.
```

In our run, the agent called `rsl-ie/export-start` with the format `json`, the category, the Status filter and the eight fields renamed through `column_headers`. When the job finished, `rsl-ie/file-get` returned `posts.json`, 5,224 bytes, the same size as the file from the wizard.

## FAQ

### Why not use the REST API?

You can. A JSON file is useful when the front end should build without a connection to WordPress, or when you want the content in the repository with its history.

### Can I export pages for the front end too?

Yes. Run the same export with Pages; add Parent Title or the parent’s slug if your front end builds nested URLs.

### Can I include custom fields or ACF fields?

Yes. Add them from **Custom Fields** or **ACF Fields** in the field list and rename them like the other columns.

### Is the content HTML or Markdown?

HTML, as WordPress stores it. Render it with `set:html` in Astro or `dangerouslySetInnerHTML` in React, or convert it to Markdown in your build if you prefer.

## Related Guides

- [How to Export WordPress Content to JSON for AI and LLMs](https://wpimportexport.com/export-wordpress-content-json-for-ai/)
- [Export WordPress Posts to XML for Feeds and Partner Sites](https://wpimportexport.com/export-wordpress-posts-xml-feed-partners/)
- [Incremental WordPress Exports: Export Only What Changed Since Last Time](https://wpimportexport.com/incremental-wordpress-export-changed-since-last-time/)
- [Export WordPress Posts with Featured Image URL and Categories to Excel](https://wpimportexport.com/export-wordpress-posts-featured-image-url-excel/)

Get the free plugin on [WordPress.org](https://wordpress.org/plugins/import-export-by-rockstarlab/).
