How can I convert Markdown to JSON and save it as Notion page blocks using n8n?

Below is one common approach to achieve this in n8n by chaining the community node’s output to a Notion node that creates or appends block children.

---

1. Convert Markdown to JSON Blocks

Use the n8n-nodes-notion-markdown community node by @JingerTea. This node converts your lengthy markdown document into a JSON array. Each element in the array is a Notion-compatible block (for example, a paragraph block). Verify that the output looks similar to:

JSONCopied
[
  {
    "object": "block",
    "type": "paragraph",
    "paragraph": {
      "rich_text": [
        {
          "type": "text",
          "text": { "content": "Your markdown content here" }
        }
      ]
    }
  },
  …
]

---

2. Use the Notion Node to Insert the Blocks

Once you have the JSON blocks, you can use a Notion node with one of these operations:

• Create Page: If you want to create a new page with your content. Here you include the blocks in the children parameter.
• Append Block Children: If you already have a page and simply wish to add blocks to it. In this case, you set the block_id to your page’s ID and pass the JSON block array as the children parameter.

---

3. Set Up the Notion Node

For example, to append the blocks to an existing page:

1. Choose Operation: Set the Notion node operation to "Append After" (which uses the [Append block children] endpoint).

2. Configure Block ID: Provide the Notion page ID where you want the content to be added.

3. Pass the Blocks: In the node’s parameters, set the children field to use the JSON output from your markdown conversion node.

Here’s a simplified illustration of what the workflow might look like:

MERMAIDCopied
graph TD;
    A[Markdown Document] --> B[n8n-nodes-notion-markdown];
    B --> C[Set up Notion Node (Append Block Children)];

And a sample JSON structure when creating a page could look like this:

JSONCopied
{
  "parent": { "page_id": "YOUR_PAGE_ID" },
  "properties": {
    "title": [
      {
        "type": "text",
        "text": { "content": "My Document Title" }
      }
    ]
  },
  "children": [
    {
      "object": "block",
      "type": "paragraph",
      "paragraph": {
        "rich_text": [
          { "type": "text", "text": { "content": "Your converted markdown block content" } }
        ]
      }
    },
    // ...other blocks
  ]
}

If you’re appending content instead, the Notion node will let you specify the block_id and the children array. The JSON array coming from the community node can be directly fed into this parameter.

---

4. Test Your Workflow

Before running a large import, test with a small markdown sample. Check the result in Notion to ensure that all blocks are formatted as expected.

---

Following these steps will help you take the JSON-formatted output from the community markdown node and implement it as blocks in a Notion page using n8n. Happy automating!

Below is an outline of a potential workflow to achieve this:

---

1. Convert Markdown to Notion-Compatible JSON

• Use the community node (n8n-nodes-notion-markdown) to convert your markdown document into the JSON format that Notion expects.
• The output you receive from this conversion will be an array of JSON objects representing individual blocks.

---

2. Create or Identify a Notion Page

• If you don’t already have a page to update, use the Notion node’s Database Page or Page operation (e.g., Create) to generate a new page in the desired database.
• The new page will have an ID you'll need for appending blocks later.

---

3. Append the JSON Blocks to the Notion Page

• The Notion node supports block-level operations such as Append After. This is used for inserting new block content after a given existing block (or at the end of the page).
• In your workflow, after the markdown is converted, add another Notion node, select the Block resource with the Append After operation.
• In the node’s parameters, set the "Block ID" that references the location within the page where you’d like to insert your blocks (often this is the page’s ID or a specific block within it).
• Map the JSON output from your markdown conversion node to the blocks field of this Notion node.

---

Example Workflow Outline

1. Markdown Conversion Node

   • Input: Long markdown text
   • Output: JSON array of block objects

2. Notion Page Node (Create Page)

   • Operation: Create a new page (or retrieve an existing page ID)

3. Notion Block Node (Append After)

   • Operation: Append After
   • Block ID: (ID of the page or the last block where you want to append content)
   • Blocks: Map the JSON output from the conversion node

Here’s a pseudo-code snippet showing the mapping:

JSONCopied
{
  "operation": "append",
  "blockId": "={{$json[\"pageId\"]}}",
  "blocks": "={{$json[\"markdownJsonOutput\"]}}"
}

(Adjust the expressions according to your exact data structure.)

---

Final Notes

• Double-check that the JSON structure produced by the community node matches Notion’s specifications for blocks.
• Use Notion’s API documentation for any details on block structure or additional parameters that might be needed.
• Test the workflow with a small markdown sample to ensure that blocks are correctly created before bulk loading lengthy documents.

This approach keeps your operations modular within n8n and leverages the native Notion node’s block management capabilities to integrate your markdown content seamlessly into Notion pages.