Web Previews

Offer your editors side-by-side previews of unpublished/draft content, directly within DatoCMS

This is a Community Plugin! Learn how create your own plugin, or copy and remix existing ones in our documentation

Web Previews DatoCMS plugin

This plugin adds side-by-side previews, and quick links in the record sidebar to preview your webpages.

🚨 Important: This is not a drag & drop plugin! It requires a lambda function on your frontend website(s) in order to function. Read more in the following sections!

Installation and configuration

Once the plugin is installed you need to specify:

A list of frontends. Each frontend specifies a name and a preview webhook, which will be called as soon as the plugin is loaded. Read more about it on the next chapter.
Sidebar open: to specify whether you want the sidebar panel to be opened by default.

⚠️ For side-by-side previews to work, if your website implements a Content Security Policy frame-ancestors directive, you need to add https://plugins-cdn.datocms.com to your list of allowed sources, ie.:

1
Content-Security-Policy: frame-ancestors 'self' https://plugins-cdn.datocms.com;

The Previews webhook

Each frontend must implement a CORS-ready JSON endpoint that, given a specific DatoCMS record, returns an array of preview link(s).

The plugin performs a POST request to the Previews webhook URL, passing a payload that includes the current environment, record and model:

1
{
2
  "item": {…},
3
  "itemType": {…},
4
  "currentUser": {…},
5
  "environmentId": "main",
6
  "locale": "en",
7
}

item: CMA entity of the current record
itemType: CMA entity of the model of the current record
currentUser: CMA entity of the collaborator, SSO user or account owner currently logged in
environmentId: the current environment ID
locale: the locale currently active on the form

The endpoint is expected to return a 200 response, with the following JSON structure:

1
{
2
  "previewLinks": [
3
    {
4
      "label": "Published (en)",
5
      "url": "https://mysite.com/blog/my-article"
6
    },
7
    {
8
      "label": "Draft (en)",
9
      "url": "https://mysite.com/api/preview/start?slug=/blog/my-article"
10
    }
11
  ]
12
}

The plugin will show all the preview links that are returned. If you want to make sure that a preview's URL is reloaded after each save, you can include an extra option (please be aware that because of cross-origin iframe issues, maintaining the scroll position between reloads will not be possible):

1
{
2
  "label": "Draft (en)",
3
  "url": "https://mysite.com/api/preview/start?slug=/blog/my-article",
4
  "reloadPreviewOnRecordUpdate": { "delayInMs": 100 }
5
}

Implementation examples

If you have built alternative endpoint implementations for other frameworks/SSGs, please open up a PR to this plugin and share it with the community!

Next.js

We suggest you look at the code of our official Next.js Starter Kit:

Route handler called returning the preview links: app/api/preview-links/route.tsx
Route handlers to toggle Next.js Draft Mode: app/api/draft-mode/enable/route.tsx and app/api/draft-mode/disable/route.tsx

Lightweight Authentication

In our Next.js starter kit, the preview link URLs also include a token query parameter that the plugin would send to the webhook receiver, like https://www.mywebsite.com/api/preview-links?token=some-secret-ish-string. The token is a string of your choice that just has to match in both the plugin settings and in your frontend's environment variables. While not encryption, this token is an easy way to limit access to your preview content.

Nuxt 3

Below here, you'll find a similar example, adapted for Nuxt. For the purpose of this example, let's say we want to return a link to the webpage that contains the published content.

If you deploy on a provider that supports edge functions, Nuxt 3 applications can expose a dynamic API: files in the /server/api folders will be converted into endpoints. So it's possible for DatoCMS to make a POST request to the Nuxt app with the info about the current record. What we'll actually do, is to implement a CORS enabled API endpoint returning an array of preview links built on the base of the record, the item type and so on:

1
// Put this code in the /server/api directory of your Nuxt website (`/server/api/preview-links.ts` will work):
2
// this function knows how to convert a DatoCMS record into a canonical URL within the website.
3

4
// this function knows how to convert a DatoCMS record
5
// into a canonical URL within the website
6
const generatePreviewUrl = ({ item, itemType, locale }) =&gt; {
7
  switch (itemType.attributes.api_key) {
8
    case 'landing_page':
9
      return `/landing-pages/${item.attributes.slug}`;
10
    case 'blog_post':
11
      // blog posts are localized:
12
      const localePrefix = locale === 'en' ? '' : `/${locale}`;
13
      return `${localePrefix}/blog/${item.attributes.slug[locale]}`;
14
    default:
15
      return null;
16
  }
17
};
18

19
export default eventHandler(async (event) =&gt; {
20
  // In this method, we'll make good use of the utility methods that
21
  // H3 make available: they all take the `event` as first parameter.
22
  // For more info, see: https://github.com/unjs/h3#utilities
23

24
  // Setup content-type and CORS permissions.
25
  setResponseHeaders(event, {
26
    'Content-Type': 'application/json',
27
    'Access-Control-Allow-Origin': '*',
28
    'Access-Control-Allow-Methods': 'POST',
29
    'Access-Control-Allow-Headers': 'Content-Type, Authorization', // add any other headers you need
30
  })
31

32
  // This will allow OPTIONS request
33
  if (event.req.method === 'OPTIONS') {
34
    return send(event, 'ok')
35
  }
36

37
  // Actually generate the URL using the info that DatoCMS is sending.
38
  const url = generatePreviewUrl(await readBody(event))
39

40
  // No URL? No problem: let's send back no link.
41
  if (!url) {
42
    return { previewLinks: [] }
43
  }
44

45
  // Let's guess the base URL using environment variables:
46
  // if you're not working with Vercel or Netlify,
47
  // ask for instructions to the provider you're deploying to.
48
  const baseUrl = process.env.VERCEL_BRANCH_URL
49
    ? // Vercel auto-populates this environment variable
50
      `https://${process.env.VERCEL_BRANCH_URL}`
51
    : // Netlify auto-populates this environment variable
52
      process.env.URL
53

54
  // Here is the list of links we're returnig to DatoCMS and that
55
  // will be made available in the sidebar of the record editing page.
56
  const previewLinks = [
57
    // Public URL:
58
    {
59
      label: 'Published version',
60
      url: `${baseUrl}${url}`,
61
    },
62
  ]
63

64
  return { previewLinks }
65
})

SvelteKit 2

Below here, you'll find a similar example, adapted for SvelteKit. For the purpose of this example, let's say we want to return a link to the webpage that contains the published content.

Create a +server.ts file under src/routes/api/preview-links/ with following contents:

1
import { json } from '@sveltejs/kit';
2

3
const generatePreviewUrl = ({ item, itemType, locale }: any) =&gt; {
4
  switch (itemType.attributes.api_key) {
5
    case 'landing_page':
6
      return `/landing-pages/${item.attributes.slug}`;
7
    case 'blog_post':
8
      // blog posts are localized:
9
      const localePrefix = locale === 'en' ? '' : `/${locale}`;
10
      return `${localePrefix}/blog/${item.attributes.slug[locale]}`;
11
    case 'post':
12
      return `posts/${item.attributes.slug}`;
13
    default:
14
      return null;
15
  }
16
};
17

18
const corsHeaders = {
19
  'Access-Control-Allow-Origin': '*',
20
  'Access-Control-Allow-Methods': 'POST',
21
  'Access-Control-Allow-Headers': 'Content-Type, Authorization',
22
  'Content-Type': 'application/json'
23
};
24

25
export async function OPTIONS() {
26
  setHeaders(corsHeaders);
27

28
  return json('ok');
29
}
30

31
export async function POST({ request, setHeaders }) {
32
  setHeaders(corsHeaders);
33

34
  const data = await request.json();
35

36
  const url = generatePreviewUrl(data);
37

38
  if (!url) {
39
    return json({ previewLinks: [] });
40
  }
41

42
  const baseUrl = process.env.VERCEL_BRANCH_URL
43
    ? // Vercel auto-populates this environment variable
44
      `https://${process.env.VERCEL_BRANCH_URL}`
45
    : // Netlify auto-populates this environment variable
46
      process.env.URL;
47

48
  const previewLinks = [
49
    // Public URL:
50
    {
51
      label: 'Published version',
52
      url: `${baseUrl}${url}`
53
    }
54
  ];
55

56
  return json({ previewLinks });
57
}