How to Turn a Blog Post into a TikTok Hook and Short-Form Script

Paste a blog post, ground it in your own brand voice, and let an Agent-mode Connector node return three scroll-stopping hooks plus a beat-by-beat short-form script as ready-to-shoot structured output.

What This Integration Does

If you write long-form content but want short-form video, the bottleneck is rewriting: a 1,500-word blog post is not a 30-second TikTok script, and copy that sounds like you on the page rarely sounds like you on camera. This Spojit workflow closes that gap. You hand it a blog post, it consults a Knowledge collection that holds your brand voice and hook patterns, and it gives you back three competing hooks and a full beat-by-beat script: hook, body beats with on-screen text and spoken lines, a call to action, and suggested captions and hashtags. You stay the editor; the workflow does the first draft.

The run model is simple and synchronous. A Manual trigger starts the run with the blog post you paste in. A Knowledge node in Query mode pulls the most relevant brand-voice and hook-formula snippets from a persistent collection. An Agent-mode Connector node then writes the hooks and script, and because it is bound to a Response Schema it returns clean, predictable JSON rather than freeform prose. A Transform node tidies that JSON into a single readable draft. Nothing is posted anywhere: the output is a draft handed back to you, so re-running with the same post simply produces a fresh set of variations. Spojit does not integrate with TikTok or any social platform; the platform name here only describes the style of content you are producing.

Prerequisites

A Spojit workspace where you can create workflows and Knowledge collections.
A persistent Knowledge collection holding your brand-voice reference material: a few documents covering your tone, example hooks that performed well, banned phrases, and your typical short-form structure. See the cross-linked guides below for creating and uploading to a collection.
Familiarity with which AI model you want the agent and the query to use; Agent mode and Knowledge Query mode both consume AI credits.
No external connections are required. This workflow uses only the built-in text and json utility connectors plus the Knowledge node, none of which need authentication.

Step 1: Start with a Manual trigger

Add a Trigger node and set Trigger Type to Manual. A Manual trigger runs from the Run button, and its output is whatever request body you pass in. Define the input your draft needs, for example:

{
  "title": "5 Mistakes New Founders Make With Pricing",
  "body": "Most founders price on cost, not value. The first mistake is...",
  "platform": "TikTok",
  "target_seconds": 30
}

Downstream nodes reference these as {{ input.title }}, {{ input.body }}, {{ input.platform }} and {{ input.target_seconds }}. Keeping the platform and target length as inputs lets you reuse the same workflow for a 60-second cut or a different format without editing nodes.

Step 2: Normalize the pasted blog post with the text connector

Pasted blog text often arrives with ragged whitespace or boilerplate. Add a Connector node in Direct mode on the text connector and pick the trim tool to strip leading and trailing whitespace from {{ input.body }}, saving the result to an output variable such as clean_body. If your posts run long, add a second text Connector node using count-words on {{ clean_body.result }} so you can see the length, and optionally truncate to cap very long posts before they reach the agent. Trimming the source up front keeps the agent focused on the content rather than formatting noise, and reduces the number of tokens the agent has to read.

Step 3: Pull brand voice from a Knowledge node in Query mode

Add a Knowledge node and set its mode to Query. In Collection, choose your persistent brand-voice collection (not Transient, since you want a long-lived archive that every content workflow can read). Set Result Count to about 6 so the node returns enough hook patterns and tone examples without drowning the prompt. Write the Prompt to ask for exactly the guidance the script writer needs, templating in the post topic:

Return our brand voice rules, tone of voice, banned phrases,
and our best-performing short-form hook formulas that fit a
video about: {{ input.title }}

Pick the Model you want to synthesize the answer and set an Output Variable such as brand_voice. The synthesized guidance is then available as {{ brand_voice.result }} for the writing step. Because the collection is workspace-scoped, the same brand-voice source feeds every creator workflow you build, so you maintain your voice in one place.

Step 4: Generate hooks and script with an Agent-mode Connector node

Add a Connector node and switch it to Agent mode. Agent mode is the in-workflow AI that does the actual writing and reasoning here. Give it a focused instruction that pulls together the cleaned post, the platform, the target length, and the brand-voice guidance:

You are a short-form video scriptwriter for our brand.
Platform: {{ input.platform }}. Target length: {{ input.target_seconds }} seconds.

Brand voice and hook formulas to follow strictly:
{{ brand_voice.result }}

Source blog post titled "{{ input.title }}":
{{ clean_body.result }}

Write THREE distinct scroll-stopping hooks, then a beat-by-beat
script for the strongest hook: each beat has an on-screen text line
and a spoken line, plus a final call to action, caption, and hashtags.

This is the step that replaces hours of manual rewriting. The agent reads the post and the brand-voice context and drafts the hooks and script in one pass. Set the node's Output Variable, for example draft.

Step 5: Force structured output with an Agent-mode Response Schema

Freeform script text is hard to reuse, so bind the Agent-mode node to a Response Schema. The schema forces the agent to return predictable JSON every run, which keeps the downstream Transform node reliable. Define a schema along these lines:

{
  "type": "object",
  "properties": {
    "hooks": { "type": "array", "items": { "type": "string" }, "minItems": 3, "maxItems": 3 },
    "chosen_hook": { "type": "string" },
    "beats": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "on_screen_text": { "type": "string" },
          "spoken_line": { "type": "string" }
        },
        "required": ["on_screen_text", "spoken_line"]
      }
    },
    "call_to_action": { "type": "string" },
    "caption": { "type": "string" },
    "hashtags": { "type": "array", "items": { "type": "string" } }
  },
  "required": ["hooks", "chosen_hook", "beats", "call_to_action"]
}

With the schema attached, {{ draft.hooks }}, {{ draft.beats }} and the rest are guaranteed fields you can address directly instead of parsing prose.

Step 6: Assemble a ready-to-shoot draft with a Transform node and json tools

Add a Transform node to turn the structured object into one readable draft a creator can shoot from. If you want to flatten or reshape first, add a Connector node on the json connector: use pick to keep only the fields you need, or stringify to render the object as text. In the Transform node, lay out the hooks, the chosen hook, each beat's on-screen and spoken line, and the call to action, pulling from {{ draft }}. For example, you might produce:

HOOKS (pick one):
1) {{ draft.hooks.[0] }}
2) {{ draft.hooks.[1] }}
3) {{ draft.hooks.[2] }}

SCRIPT
Hook: {{ draft.chosen_hook }}
... beats ...
CTA: {{ draft.call_to_action }}
Caption: {{ draft.caption }}

To list the beats, add a Loop node in ForEach mode over {{ draft.beats }} and append each {{ beat.on_screen_text }} and {{ beat.spoken_line }} as a numbered line. The final draft is the workflow's output, ready to copy into your editor or record from directly.

Step 7: Deliver the draft back to yourself

If you run this manually, the draft is visible in the run output. To get it in your inbox, add a Send Email node, which sends from Spojit's built-in mail service with no connection needed. Set Recipients to your own address, a templated Subject like Short-form draft: {{ input.title }}, and put the assembled draft in the Body. Only upstream variables resolve in this node, so reference the Transform output directly. Remember external recipients must be on your org allowlist under Settings > General > Email recipients.

Tips

Keep your brand-voice collection tight and current. A handful of strong example hooks and clear tone rules guide the agent far better than a large, vague dump of old posts.
Scaffold this workflow fast by describing it to Miraxa, the intelligent layer across your automation, then fine-tune each node in the properties panel. A prompt like "Add a Knowledge node in Query mode that reads my brand-voice collection, then an Agent-mode Connector node that writes three hooks and a script" gets the canvas most of the way there.
Expose target_seconds as an input so the same workflow produces a 15, 30, or 60-second cut without edits, and feed it into the agent prompt.
Use the text connector's slugify tool on {{ input.title }} if you want a tidy filename or subject line for each draft.

Common Pitfalls

Skipping the Response Schema. Without it the agent returns prose, and the Transform node and any {{ draft.beats }} references break. Always bind the schema in Agent mode when you need structured output.
Querying a collection with a different embedding model than it was created with. A collection's embedding model is fixed at creation; query it with the same model so retrieval stays accurate.
Forgetting that Agent mode and Knowledge Query mode consume AI credits on every run. Trim long posts in Step 2 and cap Result Count to keep token usage and cost down.
Expecting Spojit to publish or schedule the video. This workflow produces a draft only; Spojit has no native TikTok integration, so the output is handed back to you to record and post.

Testing

Validate on one short post first. Click Run with a small request body containing a single trimmed blog post and a target_seconds of 30, then open the execution log and check each node's output: confirm the Knowledge node returned brand-voice guidance, the Agent-mode node produced exactly three hooks and a beat list matching the schema, and the Transform node assembled a clean draft. Tune the agent prompt and the brand-voice documents until the voice sounds like you, then start pasting real posts. Once the output is reliable, you can add the Send Email node or wire the workflow into a larger content pipeline.