Using Draft Mode to fetch unpublished content from Contentful APIs

Overview

To allow your users to preview content changes before publishing them, you will need to configure your application to fetch “preview” content from Contentful’s APIs correctly.

You can then leverage Vercel’s Draft Mode feature inside your application to adapt your Contentful API calls to fetch preview content only when Draft Mode is enabled.

How your specific applications constructs queries and fetches data from Contentful APIs will likely vary depending on your specific use case. This guide provides concrete examples that you can take as a starting point and hopefully adapt to your own application.

Prerequisites

You will need to provide a way for your content editors to “activate” Draft Mode in your application:

• You can install the Vercel app and follow our guidance for setting up a route handler to activate Draft mode in a separate topic in this guide.
• You can follow Vercel’s instructions for enabling Draft Mode in the Vercel Toolbar. (Note that the Vercel toolbar is not compatible with Contentful’s side by side preview features, including Live Preview).

Configuring Contentful API keys for accessing preview content

Accessing Contentful’s preview APIs requires a different access token than the token used for accessing production content. A preview token is included in every API key you create for your space.

Following is how you might provision an API key and incorporate it into your Vercel-hosted Next.js project.

In your Contentful space:

1. Navigate to Settings > API Keys. Create a new API key or find the existing API key being used for your project.
2. Take note of the values for “Content Delivery API - access token” and “Content Preview API - access token” for use in the next step.
3. Navigate to Settings > General Settings
4. Take note of the value for “Space ID”

In your Vercel project:

1. Navigate to Settings > Environment Variables
2. Create an environment variable with key CONTENTFUL_ACCESS_TOKEN and use the value you copied for “Content Delivery API - access token”
3. Create an environment variable with key CONTENTFUL_PREVIEW_ACCESS_TOKEN and use the value you copied for “Content Preview API - access token”
4. Create an environment variable with key CONTENTFUL_SPACE_ID and use the value you copied for “Space ID”

Accessing preview content via Contentful’s GraphQL API

If you are using GraphQL to fetch Contentful content, you will need to adapt your GraphQL queries and HTTP requests to access preview content when Draft Mode is enabled.

In brief, you will need to adapt your Contentful GraphQL API calls to:

• Use the preview access token instead of the default access token when accessing preview content in Draft Mode
• Disable Next.js’s default caching behavior when fetching preview content in Draft Mode
• Adapt your GraphQL queries to include a preview parameter that should be set to true when your application is in Draft Mode

The example below illustrates what a working implementation of the above points might look like.

Example: GraphQL API

The examples below assume you followed the suggested guidance for provisioning an API key and adding the API tokens to your Vercel project as environment variables.

1. Create a “preview aware” fetch utility function:

1
// lib/contentful/api.ts
2
3
// preview parameter should be called with `true` when Draft Mode is enabled
4
async function fetchGraphQL(query: string, variables = {}, preview = false) {
5
  const res = await fetch(
6
    `https://graphql.contentful.com/content/v1/spaces/${process.env.CONTENTFUL_SPACE_ID}`,
7
    {
8
      method: "POST",
9
      headers: {
10
        "Content-Type": "application/json",
11
12
        // use the preview access token when preview is enabled
13
        Authorization: `Bearer ${
14
          preview
15
            ? process.env.CONTENTFUL_PREVIEW_ACCESS_TOKEN
16
            : process.env.CONTENTFUL_ACCESS_TOKEN
17
        }`,
18
      },
19
      body: JSON.stringify({
20
        query,
21
        variables,
22
      }),
23
24
      // disable caching in preview mode (via `no-store`); otherwise use `force-cache` which is the default
25
      cache: preview ? "no-store" : "force-cache",
26
    }
27
  );
28
29
  return await res.json();
30
}

2. Adapt your existing GraphQL queries to handle a “preview” boolean value correctly. (The example below assumes you have a “Blog Post” content model with some basic fields in Contentful.)

1
// lib/contentful/queries.ts
2
3
import { fetchGraphQl } from "../../../../../lib/contentful/api";
4
5
interface BlogPost {
6
  __typename: string;
7
  sys: {
8
    id: string
9
  };
10
  slug: string;
11
  title: string;
12
  description: string;
13
}
14
15
interface BlogPostCollection {
16
  items: BlogPost[];
17
}
18
19
interface FetchResponse {
20
  data?: {
21
    blogPostCollection?: BlogPostCollection;
22
  };
23
}
24
25
const BLOG_POST_GRAPHQL_FIELDS = `
26
__typename
27
sys {
28
  id
29
}
30
slug
31
title
32
description
33
`;
34
35
function extractBlogPost(fetchResponse: FetchResponse): BlogPost | undefined {
36
  return fetchResponse?.data?.blogPostCollection?.items?.[0];
37
}
38
39
// preview parameters should be called with `true` when Draft Mode is enabled
40
export async function getBlogPostBySlug(slug: string, preview: boolean = false): Promise<BlogPost | undefined> {
41
  const entries = await fetchGraphQL(
42
    // the `preview` value is passed as an argument to the query to allow unpublished entries to be returned
43
    `query {
44
      blogPostCollection(where: { slug: "${slug}" }, preview: "${preview}", limit: 1) {
45
        items {
46
          ${BLOG_POST_GRAPHQL_FIELDS}
47
        }
48
      }
49
    }`,
50
51
    // the `preview` value is also passed as the third argument to the fetchGraphQL function to trigger correct access token and caching behavior
52
    preview,
53
  );
54
  return extractBlogPost(entries);
55
}

3. When fetching Contentful content via GraphQL in your compoment, retrieve and pass through the current Draft Mode state as the preview parameter:

1
// app/blogs/[slug]/post.tsx
2
3
import { draftMode } from "next/headers";
4
import { getBlogPostBySlug } from "../../../../../lib/contentful/queries";
5
6
interface BlogPostProps {
7
  params: { slug: string };
8
}
9
10
export default async function BlogPost({ params }: BlogPostProps) {
11
  const { isEnabled: isDraftModeEnabled } = draftMode();
12
  const blogPost = await getBlogPostBySlug(params.slug, isDraftModeEnabled);
13
14
  return (
15
    <main>
16
      <h1>{blogPost.title}</h1>
17
      <div>{blogPost.description}</div>
18
    </main>
19
  );
20
}

You can adapt the above examples to your own use case, but the following files should hopefully make clear how you can take the state of Draft Mode from your page route and then adapt your query and API calls to ensure that preview content is fetched properly from Contentful.

Accessing preview content via the Content Delivery/Preview API

If you are using Contentful’s Content Delivery API Javascript SDK to fetch content entries inside your Next.js application, you will need to make a few adjustments to your application to access preview content when Draft Mode is enabled.

In brief you will need to:

• Use the preview access token instead of the default access token when initializing the Contentful.js client in your application when Draft Mode is enabled
• Specify the preview host (preview.contentful.com) during the same initialization call, again when Draft Mode is enabled.

The example below illustrates what a working implementation of the above points might look like.

Example: Content Delivery API Javascript SDK

1. Create a “preview aware” Contentful client initialization function:

1
import { createClient } from "contentful";
2
3
// preview parameter should be called with `true` when Draft Mode is enabled
4
export default function createContentfulClient(preview: boolean = false) {
5
  return createContentfulClient({
6
    space: process.env.CONTENTFUL_SPACE_ID,
7
    
8
    // use the preview access token when preview is enabled
9
    accessToken: preview
10
      ? process.env.CONTENTFUL_PREVIEW_ACCESS_TOKEN
11
      : process.env.CONTENTFUL_ACCESS_TOKEN,
12
    
13
    // specify the preview host when preview is enabled
14
    host: preview ? "preview.contentful.com" : undefined,
15
  });
16
}

2. Adapt your existing queries to handle a “preview” boolean value correctly. (The example below assumes you have a “Blog Post” content model with some basic fields in Contentful.)

1
// lib/contentful/queries.ts
2
3
import { EntryFieldTypes, Entry } from "contentful";
4
import createContentfulClient from "../../../../../lib/contentful/client";
5
6
interface BlogPost {
7
  contentTypeId: 'blogPost';
8
  fields: {
9
    slug: EntryFieldTypes.Text,
10
    title: EntryFieldTypes.Text,
11
    description: EntryFieldTypes.Text,
12
  }
13
};
14
15
export async function getBlogPostBySlug(
16
  slug: string,
17
  preview: boolean = false
18
): Promise<Entry<BlogPost> | undefined> {
19
  const client = createContentfulClient(preview);
20
  const entries = await client.getEntries<BlogPost>({
21
    content_type: 'blogPost',
22
    'fields.slug': slug,
23
  });
24
  return entries.items[0];
25
}

3. When fetching Contentful content in your compoment, retrieve and pass through the current Draft Mode state as the preview parameter:

1
// app/blogs/[slug]/post.tsx
2
3
import { draftMode } from "next/headers";
4
import { getBlogPostBySlug } from "../../../../../lib/contentful/queries";
5
6
interface BlogPostProps {
7
  params: { slug: string };
8
}
9
10
export default async function BlogPost({ params }: BlogPostProps) {
11
  const { isEnabled: isDraftModeEnabled } = draftMode();
12
  const blogPost = await getBlogPostBySlug(params.slug, isDraftModeEnabled);
13
14
  return (
15
    <main>
16
      <h1>{blogPost.title}</h1>
17
      <div>{blogPost.description}</div>
18
    </main>
19
  );
20
}

You can adapt the above examples to your own use case, but the following files should hopefully make clear how you can take the state of Draft Mode from your page route and then adapt your query and API calls to ensure that preview content is fetched properly from Contentful.