Create a table with columns:
All the necessary models are available in one API key:
This automation is a full-fledged factory for creating viral ASMR content. The system automatically generates ideas for videos about cutting various materials with a sharp knife, creates detailed scenarios from 3-6 scenes, generates videos using the ByteDance - seedance AI model, adds appropriate ASMR sounds and edits the final video with a duration of 30 seconds.
Purpose: Entry point for starting content production
Settings:
Purpose: AI creates a viral idea for an ASMR video about cutting materials
Connected components:
Main prompt:
Give me an idea about
[[
a random hard material or element being sliced with a sharp knife - have your idea be in this format: “(color) (material) shaped like a (random object)”. Examples for your inspiration: glass shaped like a strawberry, crystal shaped like a bear, dry ice shaped like a snowflake, diamond shaped like a hat, etc.
]]
Use the Think tool to review your output
System prompt:
Role: You are an AI designed to generate 1 immersive, realistic idea based on a user-provided topic. Your output must be formatted as a JSON array (single line) and follow all the rules below exactly.
RULES:
Only return 1 idea at a time.
The user will provide a key topic (e.g. “glass cutting ASMR,” “wood carving sounds,” “satisfying rock splits”).
The Idea must:
- Be under 13 words.
- Describe an interesting and viral-worthy moment, action, or event related to the provided topic.
- Can be as surreal as you can get, doesn't have to be real-world!
The Caption must be:
- Short, punchy, and viral-friendly.
- Include one relevant emoji.
- Include exactly 12 hashtags in this order:
** 4 topic-relevant hashtags
** 4 all-time most popular hashtags
** 4 currently trending hashtags (based on live research)
- All hashtags must be lower.
- Set Status to “for production” (always).
The Environment must:
- Be under 20 words.
- Match the action in the Idea exactly.
- Clearly describe:
Where the event is happening (e.g. clean studio table, rough natural terrain, laboratory bench)
Key visuals or background details (e.g. dust particles, polished surface, subtle light reflections)
Style of scene (e.g. macro close-up, cinematic slow-motion, minimalist, abstract)
- Ok with fictional settings.
The Sound must:
- Be under 15 words.
- Describe the primary sound that makes sense to happen in the video. This will be fed to a sound model later on.
OUTPUT FORMAT (single-line JSON array):
[
{
“Caption”: “Short viral title with emoji #4_topic_hashtags #4_all_time_popular_hashtags #4_trending_hashtags “,
“Idea”: “Short idea under 13 words”,
“Environment”: “Brief vivid setting under 20 words matching the action”,
“Sound”: “Primary sound description under 15 words”,
“Status”: “for production”
}
]
Structured Output Parser Schema “Parser”:
[
{
“Caption”: “Diver Removes Nets Off Whale 🐋 #whalerescue #marinelife #oceanrescue #seahelpers #love #nature #instagood #explore #viral #savenature #oceanguardians #cleanoceans”,
“Idea”: “Diver carefully cuts tangled net from distressed whale in open sea”,
“Environment”: “Open ocean, sunlight beams through water, diver and whale, cinematic realism”,
“Sound”: “Primary sound description under 15 words”,
“Status”: “for production”
}
]
WHAT IS Structured Output Parser Schema: This is a tool that forces AI to return data in a precisely defined JSON array format. Without it, AI could return an object or text in any form.
WHY IS IT NEEDED HERE:
HOW IT WORKS:
Think Tool: A special AI self-test tool that allows the model to analyze its response before making a conclusion.
Purpose: Saves the generated idea to Google Sheets for tracking
Google Sheets settings:
Table structure:
The idea
headline
Surrounding
Sound
Status
Result
[AI idea]
[Caption+ hashtags]
[Environment description]
[ASMR sound]
for production
[empty]
Purpose: AI creates 3-6 detailed scenes for videos based on an idea
Connected components:
Main prompt:
Give me 3 video scenes prompts based on the idea
System prompt:
Role: You are a prompt-generation AI specializing in cinematic, ASMR-style video prompts. Your task is to generate a multi-scene video sequence that clearly shows a sharp knife actively cutting through a specific object in a clean, high-detail setting.
Your writing must follow this style:
- Sharp, precise cinematic realism.
- Macro-level detail with tight focus on the blade interacting with the object.
- The knife must always be in motion — slicing, splitting, or gliding through the material. Never idle or static.
- Camera terms are allowed (e.g. macro view, tight angle, over-the-blade shot).
Each scene must contain all of the following, expressed through detailed visual language:
- The main object or subject (from the Idea)
- The cutting environment or surface (from the Environment)
- The texture, structure, and behavior of the material as it's being cut
- A visible, sharp blade actively cutting
Descriptions should show:
- The physical makeup of the material - is it translucent, brittle, dense, reflective, granular, fibrous, layered, or fluid-filled?
- How the material responds to the blade - resistance, cracking, tearing, smooth separation, tension, vibration.
- The interaction between the blade and the surface - light reflection, buildup of particles, contact points, residue or dust.
- Any Asmr-relevant sensory cues like particle release, shimmer, or subtle movement, but always shown visually - not narrated.
Tone:
- Clean, clinical, visual.
- No poetic metaphors, emotion, or storytelling.
- Avoid fantasy or surreal imagery.
- All description must feel physically grounded and logically accurate.
Length:
- Each scene must be between 1,000 and 2,000 characters.
- No shallow or repetitive scenes - each must be immersive, descriptive, and specific.
- Each scene should explore a distinct phase of the cutting process, a different camera perspective, or a new behavior of the material under the blade.
Inputs:
Idea: “{{$json ['Idea']}}”
Environment: “{{$json ['Environment']}}”
Sound: “{{$json ['Sound']}}”
Format:
Idea: “...”
Environment: “...”
Sound: “...”
Scene 1: “...”
Scene 2: “...”
Scene 3: “...”
Scene 4: “...”
Scene 5: “...”
Scene 6: “...”
Structured Output Parser Schema “Parser2":
{
“Idea”: “An obsidian rock being sliced with a shimmering knife”,
“Environment”: “Clean studio table, subtle light reflections”,
“Sound”: “Crisp slicing, deep grinding, and delicate crumbling”,
“Scene 1": “Extreme macro shot: a razor-sharp, polished knife blade presses into the dark, granular surface of an obsidian rock, just beginning to indent. “,
“Scene 2": “Close-up: fine, iridescent dust particles erupt from the point of contact as the blade cuts deeper into the obsidian, catching the studio light. “,
“Scene 3": “Mid-shot: the knife, held perfectly steady, has formed a shallow, clean groove across the obsidian's shimmering surface, revealing a new, smooth texture.”
}
WHAT IS Structured Output Parser Schema: Here, the scheme provides structured scenarios in object format with separate fields for each scene.
WHY IS IT NEEDED HERE:
HOW IT WORKS:
Purpose: JavaScript extracts all scenes from the AI response and prepares them for video generation
JavaScript code:
function FindSceneEntries (obj) {
const scenes = [];
for (const [key, value] of Object.entries (obj)) {
if (Key.toLowerCase () .startsWith (“scene”) && typeof value === “string”) {
scenes.push (value);
} else if (typeof value === “object” && value! == null) {
scenes.push (... findSceneEntries (value));
}
}
return scenes;
}
let output = [];
try {
const InputData = items [0] .json;
const scenes = FindSceneEntries (InputData);
if (scenes.length === 0) {
throw new Error (“No scene keys found at any level. “);
}
output = scenes.map (scene => ({description: scene}));
} catch (e) {
throw new Error (“Could not extract scenes properly. Details: "+ e.message);
}
return output;
What's going on:
The result: An array of objects like [{description: “Scene 1 text"}, {description: “Scene 2 text"},...]
Purpose: Creates video clips for every scene via ByteDance AI
HTTP Request settings:
What's going on:
The result:
{
“status”: “IN_QUEUE”,
“request_id”: “unique-id-123",
“response_url”:” ... “,
“status_url”: “...”
}
Purpose: Pause to generate videos
Settings:
Purpose: Downloads ready-made video clips
HTTP Request settings:
The result:
{
“video”: {
“url”: "https://fal.media/files/video123.mp4 “,
“content_type”: “video/mp4",
“file_name”: "output.mp4 “,
“file_size”: 2500000
}
}
Purpose: Generates ASMR sounds for video via MMaudio-v2
HTTP Request settings:
JSON Body:
{
“prompt”: “ASMR Soothing sound effects, {{$ ('AI Agent') .first () .json.output [0] .Sound}}”,
“duration”: 10,
“video_url”: “{{$json.video.url}}”
}
Parameters:
Batching settings:
Purpose: Pause to generate sound
Settings:
Purpose: Downloads ready-made audio files
HTTP Request settings:
Purpose: Collects the URLs of all video clips into one array
JavaScript code:
return [
{
video_urls: items.map (item => item.json.video.url)
}
];
What's going on:
The result: {video_urls: [” url1.mp4 “," url2.mp4 “," url3.mp4 “]}
Purpose: Edits all clips into one 30-second video via FFmpeg
HTTP Request settings:
JSON Body:
{
“tracks”: [
{
“id”: “1",
“type”: “video”,
“keyframes”: [
{“url”: “{{$json.video_urls [0]}}”, “timestamp”: 0, “duration”: 10},
{“url”: “{{$json.video_urls [1]}}”, “timestamp”: 10, “duration”: 10},
{“url”: “{{$json.video_urls [2]}}”, “timestamp”: 20, “duration”: 10}
]
}
]
}
Installation structure:
Batching settings:
Purpose: Pause for video processing
Settings:
Purpose: Downloads the finished edited video
HTTP Request settings:
The result:
{
“video_url”: "https://fal.media/files/final_video.mp4 “,
“duration”: 30,
“format”: “mp4"
}
Purpose: Updates Google Sheets with the URL of the finished video
Google Sheets settings:
The result is in the table:
The idea
headline
Surrounding
Sound
Status
Result
[AI idea]
[Caption+ hashtags]
[Environment description]
[ASMR sound]
for production
[Video URL]
Main stream:
Video creation (in parallel for each scene): 5. Preparing proposals → Creating clips 6. Creating clips → Expectation (240s) 7. Expectation → Retrieving clips
Creating audio: 8. Retrieving clips → Creating sounds 9. Creating sounds → Expectation1 (60s) 10. Expectation1 → Receiving sounds
Installation: 11. Receiving sounds → List Elements 12. List Elements → Creating the final video 13. Creating the final video → Expectation2 (60s) 14. Expectation2 → Getting the final video 15. Getting the final video → Recording the result
AI Connections:
It's done. This automation turns a simple idea into a ready-made professional ASMR video in 7-10 minutes!
.jpeg)
.jpeg)
.jpeg)
.jpeg)
-min.jpeg)
-min.jpeg)
.jpeg)
.jpeg)
.jpeg)
.jpeg)
-min.jpeg)
.jpeg)
-min.jpeg)
.jpeg)
.jpeg)
