Flat list layout

A publish extension adds a publish destination to Canva. Users can then publish their design to this destination via Canva's Publish menu.
This tutorial explains how to create a publish extension that uses the Flat list layout. This layout is intended for platforms that:
Require users to organize content into folders.
Don't support nested folders.
To learn more about the available layouts for publish extensions, refer to Choose a layout for a publish extension.
Step 1: Set up a Base URL
In the Developer Portal, publish extensions have a Base URL field. This indicates that the extension must provide the URL of a server that can receive and respond to HTTP requests from Canva.
To set up a Base URL, refer to either of the following guides:
​Set up a Base URL (with Glitch)​
​Set up a Base URL (with ngrok)​
You can use any programming language, framework, or architecture to handle requests from Canva, but the examples in this documentation use Express.js.
Step 2: Set up the required endpoints
A publish extension that uses the Flat list layout must support the following endpoints:
​POST /publish/resources/find​
​POST /publish/resources/get​
​POST /publish/resources/upload​
The following snippet demonstrates how to set up these endpoints with Express.js:
1
const express = require("express");
2
const fs = require("fs-extra");
3
const jimp = require("jimp");
4
const path = require("path");
5
const url = require("url");
6
​
7
const app = express();
8
​
9
app.use(express.json());
10
app.use(express.static("public"));
11
​
12
app.post("/publish/resources/find", async (request, response) => {
13
  // code goes here
14
});
15
​
16
app.post("/publish/resources/get", async (request, response) => {
17
  // code goes here
18
});
19
​
20
app.post("/publish/resources/upload", async (request, response) => {
21
  // code goes here
22
});
23
​
24
app.listen(process.env.PORT || 3000);
Copied!
This snippet also assumes the following Node.js dependencies are installed:
​express​
​fs-extra​
​jimp​
Step 3: Create an app via the Developer Portal
1.Log in to the Developer Portal.
2.Navigate to the Your integrations page.
3.Click Create an app.
4.In the App name field, enter a name for the app.
5.Agree to the Canva Developer Terms.
6.Click Create app.
Step 4: Add a publish extension to the app
1.Select Publish.
2.In the Base URL field, enter the URL of the server.
3.For the Layout option, select Flat list.
4.For the Output file types option, select the types of files a user can publish to the destination platform. The example in this tutorial requires the file types to be JPG and PNG.
5.For the Max number of pages field, enter the maximum number of pages that a user can publish of their design. The example in this tutorial requires the number of pages to be 1.
Any changes to the form save automatically.
Step 5: Provide a list of folders
When a user opens a publish extension that uses the Flat list layout, Canva sends a POST request to the following endpoint:
1
<base_url>/publish/resources/find
Copied!
This endpoint must respond with an array of "CONTAINER" resources. Canva then renders these resources as folders that the user can select.
The following snippet demonstrates how to create an array of "CONTAINER" resources based on the contents of the public directory:
1
app.post("/publish/resources/find", async (request, response) => {
2
  const dirPath = path.join(__dirname, "public");
3
​
4
  await fs.ensureDir(dirPath);
5
​
6
  const files = await fs.readdir(dirPath, {
7
    withFileTypes: true,
8
  });
9
​
10
  const resources = files
11
    .filter((dirent) => dirent.isDirectory())
12
    .map((folder) => {
13
      return {
14
        type: "CONTAINER",
15
        id: path.join(dirPath, folder.name),
16
        name: folder.name,
17
        isOwner: true,
18
        readOnly: false,
19
      };
20
    });
21
​
22
  response.send({
23
    type: "SUCCESS",
24
    resources,
25
  });
26
});
Copied!
In this case, the id of the resource is the path of directory.
Step 6: Verify that the selected folder still exists
When a user is ready to publish their design, they must select a folder.
When the user selects a folder, a Save button appears, and when the user clicks this button, Canva sends a POST request to the following endpoint:
1
<base_url>/publish/resources/get
Copied!
The body of this request includes an id property that contains the ID of the selected folder.
The endpoint must verify that:
The folder still exists on the destination platform.
The user still has access to the folder on the destination platform.
To do this, the endpoint must respond with the details of the selected folder.
The following snippet demonstrates how to verify the existence of a folder in the public directory (and how to respond with an error if the folder doesn't exist):
1
app.post("/publish/resources/get", async (request, response) => {
2
  const dirPathExists = await fs.pathExists(request.body.id);
3
​
4
  if (!dirPathExists) {
5
    response.send({
6
      type: "ERROR",
7
      errorCode: "NOT_FOUND",
8
    });
9
    return;
10
  }
11
​
12
  response.send({
13
    type: "SUCCESS",
14
    resource: {
15
      type: "CONTAINER",
16
      id: request.body.id,
17
      name: path.basename(request.body.id),
18
      isOwner: true,
19
      readOnly: false,
20
    },
21
  });
22
});
Copied!
In this case, the id property in the body of the request is the path of the selected folder.
Step 7: Upload the user's design
When the extension verifies that the selected folder exists, Canva immediately sends a POST request to the following endpoint:
1
<base_url>/publish/resources/upload
Copied!
The body of the request contains:
An array of assets. Each asset has a url property, which the extension must use to download the asset.
A parent property, which contains the id of the selected folder.
The endpoint must use this information to download the user's design to the destination platform. The following snippet demonstrates how to download assets to the selected folder:
1
app.post("/publish/resources/upload", async (request, response) => {
2
  const [asset] = request.body.assets;
3
  const image = await jimp.read(asset.url);
4
  const filePath = path.join(request.body.parent, asset.name);
5
  await image.writeAsync(filePath);
6
​
7
  response.send({
8
    type: "SUCCESS",
9
    url: url.format({
10
      protocol: request.protocol,
11
      host: request.get("host"),
12
      pathname: path.join(request.body.parent, asset.name),
13
    }),
14
  });
15
});
Copied!
If the user publishes their design as an image, Canva provides each page of the design as a separate asset. Otherwise, Canva provides the entire design as a single asset.
If you'd like to share your app with Canva's users, the url property must point to a page that lets users view their published design in context on the destination platform. For example, if a user publishes a tweet, the URL should point to the page of that tweet.
Example
1
const express = require("express");
2
const jimp = require("jimp");
3
const path = require("path");
4
const url = require("url");
5
const fs = require("fs-extra");
6
​
7
const app = express();
8
​
9
app.use(express.json());
10
app.use(express.static("public"));
11
​
12
app.post("/publish/resources/find", async (request, response) => {
13
  const dirPath = path.join(__dirname, "public");
14
​
15
  await fs.ensureDir(dirPath);
16
​
17
  const files = await fs.readdir(dirPath, {
18
    withFileTypes: true,
19
  });
20
​
21
  const resources = files
22
    .filter((dirent) => dirent.isDirectory())
23
    .map((folder) => {
24
      return {
25
        type: "CONTAINER",
26
        id: path.join(dirPath, folder.name),
27
        name: folder.name,
28
        isOwner: true,
29
        readOnly: false,
30
      };
31
    });
32
​
33
  response.send({
34
    type: "SUCCESS",
35
    resources,
36
  });
37
});
38
​
39
app.post("/publish/resources/get", async (request, response) => {
40
  const dirPathExists = await fs.pathExists(request.body.id);
41
​
42
  if (!dirPathExists) {
43
    response.send({
44
      type: "ERROR",
45
      errorCode: "NOT_FOUND",
46
    });
47
    return;
48
  }
49
​
50
  response.send({
51
    type: "SUCCESS",
52
    resource: {
53
      type: "CONTAINER",
54
      id: request.body.id,
55
      name: path.basename(request.body.id),
56
      isOwner: true,
57
      readOnly: false,
58
    },
59
  });
60
});
61
​
62
app.post("/publish/resources/upload", async (request, response) => {
63
  const [asset] = request.body.assets;
64
  const image = await jimp.read(asset.url);
65
  const filePath = path.join(request.body.parent, asset.name);
66
  await image.writeAsync(filePath);
67
​
68
  response.send({
69
    type: "SUCCESS",
70
    url: url.format({
71
      protocol: request.protocol,
72
      host: request.get("host"),
73
      pathname: path.join(request.body.parent, asset.name),
74
    }),
75
  });
76
});
77
​
78
app.listen(process.env.PORT || 3000);
Copied!

Basic layout

Nested list layout

Last modified 2mo ago

Copy link

Contents

Step 1: Set up a Base URL

Step 2: Set up the required endpoints

Step 3: Create an app via the Developer Portal

Step 4: Add a publish extension to the app

Step 5: Provide a list of folders

Step 6: Verify that the selected folder still exists

Step 7: Upload the user's design

Example