Automate Math Animations with n8n and the Mathify API

Sponsored by

Creating one math animation is useful.

Creating hundreds of them from a spreadsheet, adding music, reviewing the results, and publishing them through an automated workflow is much more powerful.

The Mathify API lets you generate mathematical animations from natural-language prompts programmatically. By connecting it to a tool like n8n, you can also incorporate those animations into workflows involving Google Sheets, content pipelines, educational platforms, AI agents, social media scheduling, or your own applications.

In this tutorial, you will build the complete foundation: create a Mathify project, submit an animation prompt, wait for the generation to finish, and retrieve the final video URL inside n8n.

What can you build with Mathify and n8n?

Imagine maintaining a Google Sheet containing prompts such as:

Animate the Pythagorean theorem
Visualize Fourier epicycles
Explain how an equation changes over time
Create a short animation about a mathematical sequence

An n8n workflow can read each prompt, send it to Mathify, wait for the animation to finish, and store the resulting video URL.

From there, the workflow can continue:

Add music
Save the result to another system
Send it for human review
Schedule it for YouTube or social media
Generate animations in batches
Feed the result into another application

This is already similar to how I use the Mathify API to create animations for YouTube from prompts stored in Google Sheets. I also use connected workflows for music and social media scheduling.

The API turns Mathify from a tool you operate manually into an animation engine that can become part of a much larger system.

What the tutorial covers

The video starts with a blank n8n workflow and builds the Mathify API Quickstart step by step.

You will learn how to:

Create a Mathify project.
Authenticate requests with your Mathify API key.
Send a natural-language animation prompt.
Receive the generated message and fragment identifiers.
Poll Mathify until the animation is ready.
Retrieve the final animation URL.
Route the completed result into the next part of your workflow.

You can also import the completed n8n workflow instead of rebuilding it manually.

Step 1: Create a Mathify project

Every animation workflow begins by creating a project through the Mathify API.

In n8n, this is an HTTP Request node using a POST request. You can provide a project name in the JSON body, or omit the body and allow Mathify to generate the title automatically.

The response includes the project ID, which the next node uses when submitting the animation prompt.

Step 2: Send the animation prompt

The next HTTP Request node sends a message to the project.

The body contains the natural-language instruction for the animation. For example:

{
  "content": "Animate the Pythagorean theorem"
}

Mathify begins generating the animation and returns information including the message ID, fragment ID, and generation status.

The fragment ID is important because it allows the workflow to check when the finished animation becomes available.

Step 3: Wait while Mathify generates the animation

Animation generation is asynchronous. The workflow should not stop or fail merely because the video is not available immediately.

Instead, the n8n workflow:

Waits for a short period.
Requests the fragment using its ID.
Checks whether the animation URL exists.
Repeats the loop when the URL is still empty.
Continues through the successful branch once the video is ready.

This gives you a reusable pattern for handling every Mathify generation without manually checking the dashboard.

Step 4: Use the completed animation

Once the animation is ready, the API response contains its URL.

At that point, n8n can send the video anywhere your workflow requires.

You might save the URL to Google Sheets, attach it to a content record, add music, send it to a reviewer, or pass it into a social media publishing workflow.

The tutorial stops after retrieving the finished result, but this final output is where the most valuable automations begin.

From one prompt to a complete content pipeline

The Quickstart generates one animation so that the API flow remains easy to understand.

A production workflow can extend the same structure considerably.

For example:

Google Sheets
      ↓
Read animation prompts
      ↓
Generate videos with Mathify
      ↓
Wait for completion
      ↓
Store the video URLs
      ↓
Add music or other processing
      ↓
Review approved animations
      ↓
Schedule them for publishing

Instead of repeatedly copying prompts into a web interface, downloading files, and moving them between tools, you can create a repeatable system.

That can be especially useful for:

Educational content creators
Mathematics and science channels
Online learning platforms
Marketing teams
Developers building educational products
Businesses producing technical content
AI agents that need animation capabilities

Quality checks and human review

Automation does not require publishing every generated result without inspection.

You can keep a human review step before scheduling the final animation. That is how I typically handle my own automated content workflow.

The Mathify API also exposes evaluation information, including visual and engagement-related scoring, which can help a workflow decide whether an animation meets a chosen quality threshold before it continues.

This makes it possible to combine automation with quality control rather than choosing between them.

Mathematical animation as infrastructure

The broader goal of the Mathify API is to make mathematical animation an infrastructure building block.

Developers, content creators, and businesses should be able to call an animation engine from their own applications and workflows instead of treating animation as an entirely manual production process.

n8n is a particularly useful way to begin because it lets you connect the API visually to spreadsheets, databases, storage systems, review steps, notifications, and publishing platforms.

But the API is not limited to n8n. The same endpoints can be used from your own backend, application, script, AI agent, or internal platform.

Start building

Watch the full tutorial to build the workflow from scratch, or import the completed n8n example and connect it to your Mathify API key.

Video tutorial:
https://youtu.be/VcirYsgqyUI

Mathify API documentation:
https://mathify.dev/docs

Download the n8n Quickstart workflow:
https://dub.sh/quickstart-example

This tutorial covers the foundation. The next tutorials will expand it into larger workflows involving Google Sheets, batch generation, music, quality review, and automated publishing.

How 2M+ Professionals Stay Ahead on AI

AI is moving fast and most people are falling behind.

The Rundown AI keeps you ahead of the curve.

It's a free AI newsletter that keeps you up-to-date on the latest AI news, and teaches you how to apply it in just 5 minutes a day.

Plus, complete the quiz after signing up and they’ll recommend the best AI tools, guides, and courses — tailored to your needs.

Sign up to start learning.