How to Summarize Audience Comments into Weekly Content Ideas

Build a Spojit workflow that takes a week of exported audience comments, clusters them into sentiment and recurring questions, and emails you a ranked list of content ideas plus reply-worthy comments every Monday morning.

What This Integration Does

If you make videos, posts, or newsletters, your comment sections are the single richest source of content ideas you have, and the hardest to read at scale. This workflow turns a raw export of audience comments (a CSV you download from your platform's creator dashboard or pull together by hand) into a structured weekly briefing: the dominant sentiment, the questions people keep asking, the themes worth turning into your next piece, and the specific comments that deserve a personal reply. Instead of scrolling hundreds of comments on a Sunday night, you open one email and you already know what to make and who to talk to.

The workflow runs on a Schedule trigger (a weekly cron). On each run it reads the comments you exported into a CSV, uses the csv connector to turn the rows into clean JSON, then passes that list to an Agent-mode Connector node that clusters the comments into themes and pulls out reply-worthy ones, returning a strict JSON shape via a Response Schema. A Transform node formats that JSON into a readable email body, and a Send Email node delivers the briefing to you. The run leaves no stored state: each week is computed fresh from whatever export is in place, so re-running simply recomputes against the current data, which makes it safe to test repeatedly.

Prerequisites

A Spojit workspace where you can create a workflow and add nodes on the canvas.
A weekly export of audience comments as CSV text. At minimum a comment column; ideally also author, timestamp, post or video title, and a permalink. You can paste the CSV into the run, host it at a URL, or drop it in a file store: this tutorial pastes it through the trigger for simplicity.
Your own email address added to the org allowlist under Settings → General → Email recipients so the Send Email node can deliver to you.
Enough AI credits available, since the Agent-mode Connector node consumes credits per run. One weekly run over a few hundred comments is inexpensive.
No external connection is required for the csv, json, and text connectors: they are built-in utilities that run in-process with no auth.

Step 1: Add a Schedule trigger for the weekly run

On a new workflow canvas, add a Trigger node and set its type to Schedule. Schedule triggers use a 5-field Unix cron expression plus an IANA timezone. For a Monday 8am briefing in Sydney, set the cron to 0 8 * * 1 and the timezone to Australia/Sydney. The trigger output is { scheduledAt }, which you can reference downstream as {{ trigger.scheduledAt }} when you want to stamp the briefing with its run time.

For this tutorial the comment CSV is supplied as a workflow variable so the schedule run has data to read. While you build, you can also flip the trigger to Manual and use the Run button to pass a test body, then switch back to Schedule once it works. A single trigger can hold multiple schedules if you later want, say, both a Monday and a Thursday digest.

Step 2: Parse the exported comments with the csv connector

Add a Connector node in Direct mode on the csv connector and choose the to-json tool. Direct mode is deterministic and costs no AI credits, which is exactly what you want for a predictable data-shaping step. Point its input at your raw CSV text (for example {{ trigger.commentsCsv }} if you pass the export in on the trigger body). The to-json tool converts each CSV row into a JSON object keyed by the header row, giving you an array like this:

[
  {
    "author": "mara_makes",
    "comment": "Please do a part 2 on lighting for small rooms",
    "post": "Desk setup tour",
    "url": "https://example.com/p/123#c45",
    "timestamp": "2026-06-16T14:02:00Z"
  },
  {
    "author": "devon_q",
    "comment": "The audio was way too quiet this episode",
    "post": "Q&A live",
    "url": "https://example.com/p/124#c9",
    "timestamp": "2026-06-16T15:40:00Z"
  }
]

If your export has noisy or duplicated rows, you can chain a second csv Direct-mode node using dedupe before to-json, or use filter to drop empty comment rows. Keep the column you care about (the comment text) consistently named so later steps can reference it.

Step 3: Cluster comments into themes with an Agent-mode Connector node

Add a Connector node and switch it to Agent mode. This is the node that does the actual reading and reasoning: the agent receives the list of comments and groups them into sentiment buckets, recurring questions, and content themes. Give it a clear prompt and pass in the parsed comments. For example:

You are analyzing a week of audience comments for a content creator.
Here are the comments as JSON:
{{ csv_to_json.result }}

Cluster them into recurring THEMES. For each theme give a short label,
the count of comments that fit it, the overall sentiment
(positive, negative, mixed, or question), and one suggested piece of
content the creator could make in response. Separately, pick the
comments most worth a personal reply (genuine questions, strong fans,
or complaints that need a human answer).

Use {{ csv_to_json.result }} (the output variable name of your Step 2 node) so the agent sees the real data. Agent mode is the right choice here because the work is judgment, not a single deterministic tool call. This is the in-workflow runtime AI doing the clustering: it is not Miraxa. Miraxa is the chat surface you use while building or debugging the workflow, and you can absolutely scaffold this whole canvas by asking Miraxa, then fine-tune each node by hand.

Step 4: Force a clean JSON shape with a Response Schema

Free-form AI text is hard to template into an email reliably, so attach a Response Schema to the Agent-mode node. The schema forces the agent to return structured JSON in exactly the shape your email step expects. Define it to match the briefing you want:

{
  "type": "object",
  "properties": {
    "overall_sentiment": { "type": "string" },
    "themes": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "label": { "type": "string" },
          "count": { "type": "integer" },
          "sentiment": { "type": "string" },
          "content_idea": { "type": "string" }
        },
        "required": ["label", "count", "sentiment", "content_idea"]
      }
    },
    "reply_worthy": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "author": { "type": "string" },
          "comment": { "type": "string" },
          "why": { "type": "string" },
          "url": { "type": "string" }
        },
        "required": ["author", "comment", "why"]
      }
    }
  },
  "required": ["overall_sentiment", "themes", "reply_worthy"]
}

With the schema in place, the node's output (say {{ analysis.result }}) is guaranteed to carry themes, reply_worthy, and overall_sentiment arrays and fields you can address directly. If you want to sort or trim the agent's output before emailing (for example, keep only the top five themes), add a json Direct-mode node using query or pick against {{ analysis.result }}.

Step 5: Format the briefing with a Transform node

Add a Transform node to turn the structured analysis into a readable plain-text email body. The Transform node reshapes data between steps, so here it walks the themes and reply_worthy arrays and produces a single string. Build something like:

Your weekly content briefing ({{ trigger.scheduledAt }})

Overall sentiment: {{ analysis.result.overall_sentiment }}

TOP THEMES
{{ each theme in analysis.result.themes }}
- {{ theme.label }} ({{ theme.count }} comments, {{ theme.sentiment }})
  Idea: {{ theme.content_idea }}
{{ /each }}

WORTH A REPLY
{{ each c in analysis.result.reply_worthy }}
- {{ c.author }}: "{{ c.comment }}"
  Why: {{ c.why }}  {{ c.url }}
{{ /each }}

If you prefer to do string work with utilities instead, you can reach for the text connector in Direct mode (for example join to glue lines together, truncate to cap long comments, or trim to clean whitespace) and the json connector's stringify to render any nested structure. Save the assembled string to an output variable such as {{ briefing.body }}.

Step 6: Email the briefing to yourself with a Send Email node

Add a Send Email node. It sends from Spojit's built-in mail service, so no connection is needed. Set Recipients to your own address (it must be on the org allowlist), set Subject to something templated like Weekly content ideas - {{ trigger.scheduledAt }}, and set Body to {{ briefing.body }} from Step 5. Leave Reply-To as the default (the workflow owner). For a weekly digest, set If sending fails to Fail the workflow so a delivery problem shows up clearly in your execution history rather than passing silently.

If you would rather the briefing arrive from your own creator domain instead of Spojit's mail service, swap the Send Email node for a Connector node on the resend connector using the send-email tool, or the smtp connector using send-email, and map the same recipient, subject, and body fields.

Step 7: Save, enable, and confirm the schedule

Save the workflow. While the trigger is still Schedule, double-check the cron expression and timezone read the way you expect (for example 0 8 * * 1 is 8am every Monday in the timezone you chose). Enable the workflow so the schedule becomes active. Each weekly run appears as its own entry in your execution history, where you can open it to inspect the parsed comments, the agent's structured output, and the email that went out.

Tips

Keep the comment column name consistent across exports. The Agent-mode prompt and the schema are easiest to maintain when every CSV uses the same header (for example always comment), so a column rename on the platform side does not quietly change your output.
Cap the input size. If a busy week produces thousands of comments, add a csv Direct-mode slice step (or filter by date) before the agent so you stay within a sensible token budget and keep the run fast and cheap.
Ask the agent for counts and a single content idea per theme, not paragraphs. Tighter output makes a more scannable email and a cheaper run.
Scaffold the whole canvas with Miraxa ("Build a workflow on a weekly schedule that parses a comments CSV, clusters it with an agent into themes, and emails me the result"), then tune the prompt, schema, and Transform body by hand in the properties panel.

Common Pitfalls

Skipping the Response Schema. Without it the agent may return prose that breaks your Transform templating. Always force the JSON shape so themes and reply_worthy are reliable arrays.
A recipient that is not on the allowlist. The Send Email node only delivers to addresses added under Settings → General → Email recipients; add yours before the first scheduled run.
Timezone confusion. A Schedule trigger fires in the IANA timezone you set, not the viewer's local time. Confirm the timezone so your Monday digest does not arrive Sunday night or Tuesday.
Malformed CSV. Inconsistent quoting or stray header rows in an export can make to-json produce odd objects. Add a dedupe or filter step and inspect the parsed output in a test run before trusting the schedule.

Testing

Before enabling the weekly schedule, switch the trigger to Manual and run the workflow with a small CSV of ten to twenty real comments pasted into the run body. Open the execution in your history and check each step in order: the csv to-json output is a clean array, the Agent-mode node returns JSON that matches your Response Schema, the Transform node produces a readable body, and the Send Email node delivers to your inbox. Once a small run looks right, scale up to a full week of comments, confirm the email still reads well, then switch the trigger back to Schedule and enable the workflow.