How to Repurpose a Podcast Transcript into an X Thread and a LinkedIn Post

Paste a podcast transcript into Spojit, let an Agent-mode Connector node grounded in your brand voice produce a numbered X thread and a long-form LinkedIn post as structured JSON, then use text and JSON utilities to hand you clean, ready-to-paste drafts.

What This Integration Does

If you record a podcast, every episode is a goldmine of social content that usually goes unused because turning a 45-minute transcript into a tight X thread and a polished LinkedIn post by hand takes an hour you do not have. This Spojit workflow does that repurposing for you in one run: you paste the transcript, and you get back a numbered thread sized for X and a long-form LinkedIn post, both written in your own voice rather than a generic AI register.

The run model is deliberately simple and on-demand. A Manual trigger lets you start the workflow with the transcript as input whenever a new episode drops. A Knowledge node pulls your brand-voice guidance from a persistent collection, an Agent-mode Connector node writes both pieces and returns them as a single structured JSON object, and Transform plus the text and json connectors clean the output into plain-text drafts. Nothing is posted or scheduled anywhere: the workflow produces drafts and leaves them in the run output for you to copy. Re-running with a different transcript simply produces a fresh set of drafts and changes no stored state, so you can iterate on phrasing freely.

Prerequisites

A persistent Knowledge collection holding your brand-voice guidance (tone, recurring phrases, do/do-not rules, example posts). See the related articles below to create and fill one.
The transcript text ready to paste. Plain text works best; remove speaker timestamps if you can, though the agent tolerates them.
No external connections are required: the text and json connectors are built-in utilities that run in-process with no auth, and the Knowledge and Connector nodes use AI credits from your workspace plan.
Note the exact name of the AI model you want for drafting so you can select it on the Agent-mode Connector node.

Step 1: Start with a Manual trigger that carries the transcript

Add a Trigger node and set its type to Manual. A Manual trigger runs from the Run button and exposes whatever request body you pass as the trigger output. Plan to pass a body like the one below so the rest of the workflow can reference the transcript and episode title as variables:

{
  "episodeTitle": "Why retention beats acquisition",
  "transcript": "Host: Welcome back to the show. Today we are talking about..."
}

Downstream nodes read these as {{ trigger.transcript }} and {{ trigger.episodeTitle }}. Keeping the transcript on the trigger means you never hard-code episode content into a node.

Step 2: Pull your brand voice with a Knowledge node in Query mode

Add a Knowledge node and set its mode to Query. In Collection, select the persistent collection that holds your brand-voice guidance (do not use Transient here: you want the long-lived, workspace-scoped archive). Set Prompt to something that retrieves the rules the agent should follow, for example:

Summarize this creator's brand voice, tone, recurring phrases,
formatting habits, and any rules about what to avoid, so a writer
can match their style on X and LinkedIn.

Pick an AI Model for synthesis, leave Result Count at the default of 5, and set an Output Variable such as voice. The node returns a concise brand-voice brief you can reference later as {{ voice }}. This grounding step is what keeps the drafts sounding like you instead of generic copy.

Step 3: Draft both pieces with an Agent-mode Connector node and a Response Schema

Add a Connector node and switch it to Agent mode. Agent mode lets the agent reason over your transcript and brand voice and produce judgment-based writing, and its Response Schema forces the result into a predictable JSON shape so the following utility steps never have to guess at the structure. Write a prompt that hands the agent both the transcript and the retrieved voice, for example:

You are writing social content for the podcast episode titled
"{{ trigger.episodeTitle }}".

Brand voice to match:
{{ voice }}

Transcript:
{{ trigger.transcript }}

Write a numbered X thread of 6 to 9 posts and one long-form
LinkedIn post. Keep every X post under 280 characters. Open the
thread with a strong hook. Do not invent facts that are not in
the transcript.

Define the Response Schema so the agent returns the thread as an array of strings and the LinkedIn post as one string:

{
  "type": "object",
  "properties": {
    "xThread": {
      "type": "array",
      "items": { "type": "string" }
    },
    "linkedInPost": { "type": "string" }
  },
  "required": ["xThread", "linkedInPost"]
}

Set the node's Model to your chosen drafting model and store the result in an Output Variable such as drafts. You now have {{ drafts.xThread }} (an array) and {{ drafts.linkedInPost }} (a string).

Step 4: Validate and tidy the structured output with the json connector

Add a Connector node in Direct mode on the json connector and pick the validate tool. Point it at {{ drafts }} with a small schema that re-checks the agent honored the shape, which protects the downstream steps if a model ever returns malformed output. You can reuse the same schema from Step 3.

Then add a second json Direct-mode node using the get tool to safely pull each field out for the cleaning steps, for example reading the path linkedInPost from {{ drafts }} into a variable like linkedInRaw. Working through get rather than referencing nested paths directly keeps the workflow readable and gives you one clear place to adjust if you rename a field.

Step 5: Clean the thread and post into ready-to-paste drafts with the text connector

The agent's output often carries stray leading or trailing whitespace and inconsistent line breaks. Use the text connector to fix that. Add a Connector node in Direct mode on text and use the trim tool on {{ linkedInRaw }} to remove surrounding whitespace, storing the result as linkedInClean.

For the thread, the cleanest way to produce a single copy-paste block is to join the numbered posts with blank lines between them. Add a Transform node to map {{ drafts.xThread }} into one string where each item is prefixed with its position and separated by a blank line, producing something like:

1/ The hook that opens the thread...

2/ The second point, kept under 280 characters...

3/ ...

Store the Transform output in a variable such as threadClean. If you prefer to assemble the block with utilities instead of a Transform expression, the text connector's join tool concatenates an array of strings with a chosen separator. Either way, finish with a text Direct-mode trim on the assembled thread and write the result back to threadClean so the draft starts and ends cleanly. You can also run count-chars from the text connector on each thread post during testing to confirm none exceed 280 characters.

Step 6: Hand the drafts back to yourself with a Send Email node

Add a Send Email node so the finished drafts land in your inbox ready to paste. Set Recipients to your own address (it must be on the org allowlist under Settings -> General -> Email recipients), set a templated Subject such as Drafts: {{ trigger.episodeTitle }}, and build the Body from your cleaned variables:

X THREAD
========
{{ threadClean }}

LINKEDIN POST
=============
{{ linkedInClean }}

The Send Email node uses Spojit's built-in mail service, so no connection is needed, and it counts toward your monthly email allowance. If you would rather review the drafts on the canvas, you can skip this step and read the cleaned variables straight from the run output instead.

Tips

Scaffold the whole canvas fast by describing it to Miraxa, the intelligent layer across your automation, with a prompt like "Build a workflow with a Manual trigger, a Knowledge query for brand voice, an Agent-mode Connector node with a Response Schema for an X thread and a LinkedIn post, then text cleanup," and fine-tune each node in the properties panel afterward.
Keep your brand-voice collection small and specific. A handful of strong example posts and a short list of do/do-not rules retrieve far more cleanly than a long unstructured document.
The Response Schema is what makes the rest of the workflow reliable: because xThread is always an array and linkedInPost is always a string, your json and text steps never need conditional handling.
Add a constraint such as "do not invent facts that are not in the transcript" to the agent prompt to keep the drafts grounded in what was actually said on the episode.

Common Pitfalls

Querying a Transient collection in Step 2 returns nothing, because Transient collections only hold documents embedded earlier in the same run. Your brand voice lives in a persistent collection, so select that one.
If the agent occasionally returns text outside the JSON shape, the json validate step in Step 4 catches it. Without that check, a malformed run can break the cleaning steps silently.
Very long transcripts can push past a model's context window. If a run feels truncated, trim the transcript to the segments worth repurposing before pasting, or split the work across runs.
Send Email only delivers to allowlisted recipients, so a draft email that never arrives usually means your own address is missing from Settings -> General -> Email recipients.

Testing

Validate on a short sample before relying on it. Paste a two-or-three-paragraph excerpt of a transcript into the Manual trigger body and click Run, then open the execution in the run history and inspect each node's output: confirm the Knowledge node returned a sensible voice brief, the Agent-mode Connector node returned an xThread array and a linkedInPost string, the json validate step passed, and the text cleanup produced trimmed drafts. Use the text connector's count-chars tool on a couple of thread posts to confirm they stay under 280 characters. Once a small excerpt reads the way you want, run it again with a full transcript.