DEV Community: Shash

Use SocialListeningAPI as a LinkedIn Post API for ChatGPT Research

Shash — Mon, 24 Aug 2026 02:06:15 +0000

LinkedIn posts can contain detailed product questions, launch notes, hiring plans, and complaints about tools. Finding those posts by hand takes time, and copying a few links into ChatGPT does not make the process repeatable.

We're going to useSocialListeningAPI, which provides a LinkedIn post API that searches public posts by keyword and returns normalized mentions with source URLs. ChatGPT can review those
mentions, group the useful ones, and write a comment that links back to the posts.

Let's get started.

What the LinkedIn post API returns

The keyword search endpoint is:

GET https://api.sociallisteningapi.com/api/v1/linkedin/search

It searches public LinkedIn posts by keyword, newest first. Each successful request costs 2 credits. Failed requests do not use credits.

Results use the shared social response structure. Available fields include:

id
platform
url
content.title
content.text
content.media_urls
author
engagement
published_at
ext

SocialListeningAPI also has a separate endpoint for public posts from one LinkedIn profile:

GET https://api.sociallisteningapi.com/api/v1/linkedin/profile/posts

That endpoint accepts a LinkedIn profile URL and returns public profile posts newest first, with pagination when available. Use keyword search for topic research. Use profile posts when you already know which public profile you want to follow.

Step 1: Search for a specific situation

Broad terms such as marketing or cybersecurity produce too much mixed content. A good keyword describes a problem, decision, or change.

For product research, I would begin with phrases like:

recommend a customer support tool
alternative to competitor name
competitor name pricing
how do you track brand mentions
looking for a LinkedIn post search API
we are hiring our first sales person

Each keyword/phase represents a different research question. Keep them separate so you can remove the queries that return weak results.

Avoid calling every mention a lead. A person may be researching for an article, discussing an old project, or sharing a link without looking for a product.

Step 2: Make the LinkedIn search request

Create a SocialListeningAPI account, activate it, and copy your API key. Send the key in the x-api-key header.

curl --get 'https://api.sociallisteningapi.com/api/v1/linkedin/search' \
  --data-urlencode 'query=recommend a customer support tool' \
  --header 'x-api-key: YOUR_API_KEY'

Set raw=true only when you need the unchanged provider response as well as the normalized fields:

curl --get 'https://api.sociallisteningapi.com/api/v1/linkedin/search' \
  --data-urlencode 'query=recommend a customer support tool' \
  --data-urlencode 'raw=true' \
  --header 'x-api-key: YOUR_API_KEY'

Here is the same request in JavaScript:

const url = new URL(
  "https://api.sociallisteningapi.com/api/v1/linkedin/search",
);

url.searchParams.set("query", "recommend a customer support tool");

const response = await fetch(url, {
  headers: {
    "x-api-key": process.env.SOCIALLISTENING_API_KEY,
  },
});

if (!response.ok) {
  throw new Error(`LinkedIn post search failed with status ${response.status}`);
}

const result = await response.json();
const posts = result.data.items;

console.log(posts);

Keep the API key secure on your server. Browser code, public repositories, screenshots, and logs are poor places for a private key.

Step 3: Tell ChatGPT what to research

ChatGPT needs to know what a useful mention looks like.

For a product-research workfow, use a prompt like this:

Review these public LinkedIn posts for product research.

Keep a post only when the author directly describes one of these:
- a problem they are trying to solve
- a tool recommendation request
- a named product comparison
- a pricing or access concern
- a workaround for a missing feature

For every kept post, return:
- author and published date
- exact problem or request
- product or workaround named
- direct statement from the post
- your inference, clearly labelled
- source URL

Reject job ads, event promotions, copied news, vague category mentions, and posts without enough context. Do not estimate purchase intent or lead quality. Do not draft a comment or direct message.

If a post says, “We need a way to search public comments,” that is a direct need. Saying the company has a budget or plans to buy this month would be an unsupported guess at most.

Step 4: Run the search from ChatGPT through MCP

If you prefer to stay in ChatGPT, connect the
SocialListeningAPI MCP via its MCP server. ChatGPT can call the LinkedIn search tool and receive current public mentions with source URLs.

Use a prompt that includes the query, the source, and the output limit:

Use SocialListeningAPI to search public LinkedIn posts for these phrases:
- recommend a customer support tool
- alternative to CompetitorName
- CompetitorName pricing

Return at most 10 useful posts. Include the matched query, author, published date, short context, fit reason, and source URL. Put uncertain matches in a separate list.

This search will consume SocialListeningAPI credits. ChatGPT performs the grouping and summary.

Know that ChatGPT does not create a recurring schedule, store old results, or send an alert by itself.

You can use something external like Zapier, N8N, etc for recurring social listening. Or use ChatGPT scheduled tasks for a super quick setup.

Conclusion

I hope this workflow has been useful for you. With this workflow, you can detect mentions for B2B brands/products easily and find potential leads.

If you want a proper social listening tool instead of this, I'd recommend Mentionkit. The main advantage of using a pure API solution is the cost. SociallisteningAPI has usage-based pricing and it comes a lot cheaper than existing brand monitoring products.

Build a Reddit Search API Workflow with ChatGPT and SocialListeningAPI

Shash — Fri, 21 Aug 2026 08:53:17 +0000

Reddit is great for finding people talking about your product, complaining about your competitors, etc. It is also full of repeated jokes, old advice, and posts that match a keyword for the
wrong context.

A Reddit social listening workflow should do more than collect links. It should preserve the post or
comment text, subreddit, date, and source URL, then give ChatGPT a strict rule for keeping or
rejecting each result.

For this workflow, we'll be using:

SocialListeningAPI It searches public Reddit posts and comments.
ChatGPT. It can group the returned records and write a short brief. A human still needs to read the full thread before treating a comment as evidence or joining the conversation.

PS, you can also use Claude or any other LLM, it doesn't really matter.

What this workflow is good for

I would use this setup for research jobs where the exact words matter:

Finding product recommendation questions
Collecting complaints about a product category
Finding workarounds people already use
Grouping repeated feature requests
Learning how people compare two products
Finding questions that deserve a clear help article

It is a poor fit for counting every mention or declaring broad market sentiment. A keyword result is
a sample of public Reddit content, and a single popular thread can distort the picture.

The two Reddit search endpoints

SocialListeningAPI has separate endpoints for posts and comments.

Search	Endpoint	Cost per successful request
Public posts	`/api/v1/reddit/search-posts`	1 credit
Public comments	`/api/v1/reddit/search-comments`	2 credits

Both search newest first. Post results include normalized post text, subreddit, engagement, author,
publication time, and source data. Comment results include normalized comment text, subreddit, and
source data.

The exact parameter defaults to true for both searches. SocialListeningAPI wraps the query in
double quotes when exact search is enabled. Set exact=false when you want the source search to
receive the phrase unchanged.

Step 1: Start with problem language

Searching a category name such as project management will return a large mix of discussions.
Search for language that reveals a task or decision.

For example:

recommend a project management tool
alternative to competitor name
competitor name too expensive
how do you track project delays
need a tool that exports project reports

Keep each phrase separate. You want to know which query found the result.

Run the same phrase against posts and comments when the task needs both. Posts often contain the
main question. Comments may contain product comparisons and workarounds that never appear in the
title.

Step 2: Search Reddit with the API

Create a SocialListeningAPI account, activate it, and copy your API key. You'll get free 100 credits.
Send the key in the x-api-key header.

Search public posts:

curl --get 'https://api.sociallisteningapi.com/api/v1/reddit/search-posts' \
  --data-urlencode 'query=recommend a project management tool' \
  --data-urlencode 'exact=true' \
  --header 'x-api-key: YOUR_API_KEY'

Search public comments:

curl --get 'https://api.sociallisteningapi.com/api/v1/reddit/search-comments' \
  --data-urlencode 'query=recommend a project management tool' \
  --data-urlencode 'exact=true' \
  --header 'x-api-key: YOUR_API_KEY'

Successful responses return records under data.items. Failed requests do not use credits.

For a JavaScript workflow, keep the API key on your server:

const url = new URL(
  "https://api.sociallisteningapi.com/api/v1/reddit/search-posts",
);

url.searchParams.set("query", "recommend a project management tool");
url.searchParams.set("exact", "true");

const response = await fetch(url, {
  headers: {
    "x-api-key": process.env.SOCIALLISTENING_API_KEY,
  },
});

if (!response.ok) {
  throw new Error(`Reddit search failed with status ${response.status}`);
}

const result = await response.json();
console.log(result.data.items);

Step 3: Keep the fields ChatGPT needs

Do not send only the post title to ChatGPT. That removes the context needed to make a useful call.

For each record, keep:

query
result type: post or comment
subreddit
title, when available
text
author
published_at
engagement, when available
source URL

Also keep the query beside the result. A comment may match several searches, but the query explains
why it entered this run.

Step 4: Ask ChatGPT to reject weak matches

You can connect ChatGPT through the SocialListeningAPI MCP and
ask it to run the Reddit searches, or pass API results into your own ChatGPT workflow. In both
cases, use a prompt with an explicit reject path.

Review these public Reddit posts and comments for product research.

Keep a result only when the author describes one of these:
- a clear problem
- a current workaround
- a product recommendation request
- a comparison between named tools
- a missing capability

Reject jokes, copied news, job posts, vague mentions, and results where the keyword
has a different meaning.

For each kept result, return:
- subreddit
- post or comment
- the problem in the author's own terms
- product or workaround named
- why the result fits
- published date
- source URL

Separate direct statements from your inference. Do not draft a reply.

Ask for the author's own terms because polished summaries can erase useful language. If five people
describe the same problem in five different ways, those phrases may be more valuable than a generic
label.

Step 5: Read the whole thread before using the finding

A comment can look clear when removed from its parent discussion and mean something else in the
thread. Before adding a result to a research report, check:

The post date
The subreddit and its purpose
The parent post or comment
Whether the author is speaking from experience
Whether another comment corrects the claim
Whether the linked product or policy has changed

Treat public opinions as opinions. A highly upvoted comment is still not proof that every customer
has the same problem.

If you decide to reply, read the subreddit rules and disclose your product connection when it is
relevant. Keep replies under human control. This workflow does not automate comments or direct
messages.

Step 6: Store URLs before running the search again

For a one-time research task, a ChatGPT conversation may be enough. A recurring workflow needs
external storage.

Save the result ID or source URL, query, subreddit, result type, published date, and first-seen time
in a database, n8n Data Table, or sheet. On the next run, exclude URLs already stored.

Scheduling and deduplication happen outside SocialListeningAPI. Use cron, n8n, Make, Zapier, or your
own worker when you need repeated searches.

Start weekly. Daily searches can produce nearly identical result sets for narrow phrases, which
uses credits and creates more review work without adding much information.

Step 7: Add a ChatGPT scheduled reminder

ChatGPT scheduled tasks can run in the background and return to the same chat on a schedule. I would
use this as a reminder before building a fully automatic workflow. It keeps the first few searches under human review and makes bad queries easier to spot.

Open the ChatGPT conversation that contains
your query list and ask:

Create a scheduled task in this chat.

Every Monday at 9:00 AM local time, run the weekly
Reddit product research check.

Include this checklist in the reminder:
1. Search Reddit posts and comments through SocialListeningAPI for:
   - recommend a project management tool
   - alternative to CompetitorName
   - CompetitorName too expensive
2. Check the saved-source-URL sheet before reviewing results.
3. Exclude links already seen.
4. Group new results into recommendation request, product problem,
   competitor comparison, feature request, unrelated, or unclear.
5. Keep the source URL beside every result.
6. Do not draft or publish Reddit replies.

OpenAI's scheduled tasks guide says you can create and
manage tasks from ChatGPT on the web or desktop app when the feature is enabled. Open Scheduled to
check recent runs, pause the reminder, or change its timing. Test the prompt once in a normal chat
before scheduling it, then review the first few reminders.

The scheduled task handles the reminder. SocialListeningAPI performs each search when requested,
and your sheet or database stores old URLs. ChatGPT scheduled tasks can use connected tools available
to the chat, but I would keep the first version manual until the queries and rejection rules produce
a useful brief.

Output format

Keep the final report small and sourced:

Repeated problems
- Problem, number of distinct sources, representative URLs

Recommendation questions
- Requested outcome, tools already tried, source URL

Competitor comparisons
- Products compared, stated decision factor, source URL

Unclear or conflicting claims
- What is uncertain, source URLs

Queries that produced no useful results
- Query and reason it should be changed or removed

The last section prevents a bad query from staying in the schedule forever.

Conclusion

Use the Reddit search API to collect current public posts and comments. Use ChatGPT to sort the
results. Keep the original source URL beside every finding, and read the thread before responding.

I hope this was helpful. If you're looking for a full social listening experience, try Mentionkit. SociallisteningAPI powers Mentionkit under the hood.

Automate B2B Marketing With Hermes Agent, LinkedIn, and X

Shash — Tue, 11 Aug 2026 05:01:41 +0000

Checking LinkedIn and X for posts where you can plug your product can get tiring and repetitive.

Instead of doing this manually, Hermes Agent can run the same
searches each weekday, skip posts it has already found, and prepare one short brief for review.

The SociallisteningAPI searches current public LinkedIn and X posts
and returns normalized records with source URLs. Hermes handles the schedule, deduplication,
analysis, and delivery outside the API. You still decide whether to reply or send a message.

Step 1: Connect Hermes Agent to the SocialListeningAPI MCP

Install and configure Hermes using its official setup
guide. Then create a SocialListeningAPI account and
claim the 100 free credits.

Add the SocialListeningAPI MCP as a remote OAuth server:

hermes mcp add sociallisteningapi \
  --url https://api.sociallisteningapi.com/mcp \
  --auth oauth

hermes mcp test sociallisteningapi

Complete the browser sign-in and approve access to your workspace credits. The hermes mcp
documentation covers
connection and login commands.

Run this in Hermes to confirm the connection:

List the SocialListeningAPI tools available to you. Do not run a search.

You should see search_social_posts. If the connection works but the tool is missing, start a new
Hermes session or reload the MCP tools.

Step 2: Choose searches that show a real problem

Broad searches such as marketing software return too much noise. Begin with four to eight phrases
that someone may use when asking for help, comparing tools, or describing a problem.

For a social listening product, useful examples include:

recommend a social listening tool
how to track brand mentions
missing LinkedIn mentions
LinkedIn post search API
alternative to social monitoring software
social listening tool too expensive

Keep each phrase at least four characters long and do not include quotation marks. Add your ideal
customer, excluded industries, supported locations, and minimum fit rules to the prompt.

Step 3: Test one B2B opportunity brief

Run the workflow by hand before scheduling it. Open Hermes and use this prompt:

Prepare a B2B opportunity brief from public LinkedIn and X posts.

Search both platforms for every phrase below:
- recommend a social listening tool
- how to track brand mentions
- LinkedIn post search API
- alternative to social monitoring software

Keep only posts where the author asks for a recommendation, describes the problem, compares tools,
or wants to replace a product. Exclude generic news, reposts, job posts, and promotional content.

For each useful post, return:
- platform and author
- published date
- source URL
- exact problem or request
- why it may fit a social listening API
- one helpful next action

Deduplicate by source URL. Do not contact anyone or publish a reply.

Four phrases across LinkedIn and X cost up to 12 credits per run. Each successful LinkedIn search
costs 2 credits and each successful X search costs 1. Failed requests use no credits.

Open every source before keeping it. Remove phrases that mostly find unrelated posts. A useful match
should contain a clear problem, fit the product, and still be recent enough for a reply to help.

Step 4: Save seen URLs and schedule the brief

Hermes cron jobs run in fresh sessions, so give the job a fixed working directory. This lets it keep
a small file of URLs already included in earlier briefs.

mkdir -p "$HOME/hermes-workflows/b2b-opportunity-brief"

hermes cron create "0 9 * * 1-5" \
  "Search LinkedIn and X through the SocialListeningAPI MCP for: recommend a social listening tool; how to track brand mentions; LinkedIn post search API; alternative to social monitoring software. Read seen-urls.txt if it exists and exclude stored URLs. Append each new source URL after preparing the brief. Return platform, author, published date, source URL, exact problem, fit reason, and one helpful next action. Never contact anyone or publish a reply. If there are no new useful posts, respond with only [SILENT]." \
  --workdir "$HOME/hermes-workflows/b2b-opportunity-brief" \
  --name "B2B opportunity brief" \
  --deliver local

The cron expression runs at 9:00 a.m. from Monday to Friday. Four phrases use up to 60 credits over
five runs. Reduce the phrases or frequency when that is more than you need.

Hermes needs its gateway scheduler running. Install it as a service, check the job, then trigger one
test run:

hermes gateway install
hermes cron status
hermes cron run "B2B opportunity brief"

Hermes saves local cron output under ~/.hermes/cron/output/. You can change --deliver local to a
configured Telegram, Slack, email, or other supported destination. The Hermes cron
documentation explains working
directories, delivery targets, and job history.

What SocialListeningAPI and Hermes each do

SocialListeningAPI searches public posts and returns available post data with source URLs. It does
not provide the schedule, URL history, ranking, brief, CRM update, or outreach.

Hermes performs those external steps, but its summary can be wrong. Read the original post before
acting. Keep all outreach human-approved and disclose your connection when mentioning your product.

This workflow suits founders and small B2B teams that want a short, current research queue. Use a
dedicated sales platform when you need private contact data, native CRM enrichment, or automated
outreach.

Conclusion

I hope this guide was helpful. We run this setup for our SaaS products and its been super helpful.
We're exploring on automation social media posting and other bits now.

Automate social listening with OpenClaw and Mentionkit

Shash — Thu, 09 Apr 2026 06:37:10 +0000

Social listening tools are great.

They tell you that somebody mentioned your brand, your competitor, or a keyword you care about.

Unfortunately, after that, a human still has to read the thread, decide if it matters, write a reply, and post it.

That works when volume is low. It gets messy once you want a repeatable workflow.

A better setup is to split the job in two:

use Mentionkit to collect and organize mentions
use OpenClaw to run the agent workflow

That gives you a technical pipeline instead of just another dashboard. Mentionkit gives you structured mention data plus endpoints for listing mentions, generating draft comments, and marking a mention handled. OpenClaw gives you an agent runtime plus browser control over tabs, clicks, typing, and navigation.

In this article, I will show a simple version of that setup:

pull mentions from Mentionkit
filter for real opportunities
generate a draft reply automatically
let an AI agent refine it
post it through the user’s signed-in browser session after approval
mark the mention handled so it does not get processed again

That is a good fit for teams that want more than alerts, but do not want to build a full custom agent stack from scratch.

What social listening means in this setup

For this workflow, social listening is very simple.

You track public conversations around:

your brand
your competitors
the problem you solve

For this example, I am using Mentionkit.

Why Mentionkit?

it has an API you can use right away
mentions come back as structured objects
mentions include a relevance field
you can generate a draft comment with one API call
you can mark a mention handled with one API call

The relevance part matters a lot. The mentions API supports filtering by relevance, and the allowed values are 1-5. In practice, anything with a relevance score of 3 or above is a good candidate for reply review. Mention objects also include fields like comment and commentStatus, which makes idempotent workflows much easier.

Why OpenClaw fits well here

OpenClaw is a self-hosted agent gateway with browser tooling, skills, and scheduled execution.

That matters here because the browser side is real, not theoretical.

OpenClaw’s browser stack supports deterministic tab control like list, open, focus, and close. It also supports page actions like click, type, press, navigate, and snapshot. More importantly, the built-in user browser profile can attach to your real signed-in Chrome session through Chrome MCP. The docs also say that when the attach works, tabs will list your already-open browser tabs and snapshot will operate on the selected live tab.

So yes, if the user already has Reddit, X, and LinkedIn tabs open and signed in on their local Chrome profile, OpenClaw can attach to that live browser session and operate those tabs. The main caveats are that the user profile is host-only and existing-session mode has some limits, like no batch actions and fewer network/debugging features than the isolated OpenClaw-managed profile. For simple “focus tab, type reply, submit post” workflows, it is a good fit.

The workflow

Here is the shape of the workflow:

Mentionkit -> local script -> OpenClaw agent -> approval -> user browser tab -> status update

Step 1: Pull mentions from Mentionkit

First, fetch recent mentions for a project.

import axios from "axios";

const mentionkit = axios.create({
  baseURL: "https://api.mentionkit.com",
  headers: {
    Authorization: `Bearer ${process.env.MENTIONKIT_API_KEY}`,
  },
});

async function listMentions(projectId) {
  const response = await mentionkit.get("/api/v1/mentions", {
    params: {
      projectId,
      sort: "newest",
      relevance: "3,4,5",
    },
  });

  return response.data.items;
}

The GET /api/v1/mentions endpoint supports projectId, sort, and a comma-separated relevance filter, so this is the easiest first pass.

Step 2: Ignore mentions we already handled

Mentionkit includes commentStatus on mention items, and the update endpoint only accepts commentStatus values of 1 or -1. A value of 1 is the obvious flag to use for “we already posted or handled this mention.” That means OpenClaw should ignore any mention where commentStatus === 1.

function isUsefulMention(mention) {
  if (mention.commentStatus === 1) {
    return false;
  }

  if (mention.relevance < 3) {
    return false;
  }

  return true;
}

That one check makes the workflow idempotent enough for a cron job.

Step 3: Generate a draft comment

Once you have a candidate mention, ask Mentionkit to generate the comment.

async function generateComment(mentionId) {
  const response = await mentionkit.put(`/api/v1/mentions/${mentionId}/comment`);
  return response.data;
}

PUT /api/v1/mentions/:id/comment returns the updated mention object and includes the generated comment field.

Step 4: Hand the candidates to OpenClaw

Now build the payload OpenClaw will consume:

async function getCandidates(projectId) {
  const mentions = await listMentions(projectId);
  const results = [];

  for (const mention of mentions) {
    if (!isUsefulMention(mention)) {
      continue;
    }

    const mentionWithComment = await generateComment(mention.id);

    results.push({
      id: mentionWithComment.id,
      platform: mentionWithComment.platform,
      keywordValue: mentionWithComment.keywordValue,
      authorHandle: mentionWithComment.authorHandle,
      relevance: mentionWithComment.relevance,
      text: mentionWithComment.text,
      comment: mentionWithComment.comment,
      sourceUrl: mentionWithComment.url,
    });
  }

  return results;
}

Let OpenClaw use the signed-in tabs

This is the part that matters most.

OpenClaw should use the user browser profile, not the isolated openclaw profile, because you want the agent to reuse the tabs where the user is already logged in. The browser docs explicitly say the user profile attaches to the real signed-in Chrome session, and the CLI supports listing tabs, selecting a tab, focusing it, and then clicking or typing into the page.

A practical skill would say something like this:

---
name: mentionkit-review
description: "Review Mentionkit mentions and post approved replies with the user browser profile."
---

1. Run the local Mentionkit review script.
2. Read the returned JSON.
3. Ignore mentions where commentStatus is already 1.
4. Ignore mentions where relevance is below 3.
5. Prioritize mentions with relevance 4 or 5.
6. Rewrite the draft so it sounds natural and specific to the thread.
7. Use browser profile "user".
8. List open tabs and focus the tab that matches the mention platform:
   - reddit.com for REDDIT
   - x.com for X
   - linkedin.com for LINKEDIN
9. Open the thread URL if needed.
10. Paste the final reply and submit it only after approval.
11. After a successful post, call the Mentionkit status endpoint with commentStatus: 1.
12. Record the posting receipt locally with mentionId, platform, sourceUrl, postedUrl, and postedAt.

That is the right split of responsibility. Mentionkit decides which mentions are promising. OpenClaw handles the browser work.

Updating Mentionkit after posting

Mentionkit’s status endpoint is useful, but it has one important limitation.

The documented POST /api/v1/mentions/:id request body only accepts commentStatus, and the docs show valid values of 1 or -1. The response only returns id, commentStatus, and commentStatusAt. So you can use this endpoint to mark a mention as handled, but based on the current docs you cannot store extra posting metadata like the Reddit comment URL or the exact tab where it was posted.

So the final pattern is to set commentStatus: 1 inside Mentionkit after a successful post.

Here is the Mentionkit update call:

async function updateMentionStatus(mentionId) {
  const response = await mentionkit.post(`/api/v1/mentions/${mentionId}`, {
    commentStatus: 1,
  });

  return response.data;
}

Use it like this after OpenClaw posts:

await updateMentionStatus(mention.id);

await recordPostingReceipt({
  mentionId: mention.id,
  platform: mention.platform,
  sourceUrl: mention.sourceUrl,
  postedUrl: finalPostedUrl,
  postedAt: new Date().toISOString(),
});

That gives you both layers:

Mentionkit knows the mention is already handled
your local store knows exactly where OpenClaw posted

Full filtering logic

import axios from "axios";
import fs from "fs/promises";

const mentionkit = axios.create({
  baseURL: "https://api.mentionkit.com",
  headers: {
    Authorization: `Bearer ${process.env.MENTIONKIT_API_KEY}`,
  },
});

async function listMentions(projectId) {
  const response = await mentionkit.get("/api/v1/mentions", {
    params: {
      projectId,
      sort: "newest",
      relevance: "3,4,5",
    },
  });

  return response.data.items;
}

function isUsefulMention(mention) {
  if (mention.commentStatus === 1) {
    return false;
  }

  if (mention.relevance < 3) {
    return false;
  }

  return true;
}

async function generateComment(mentionId) {
  const response = await mentionkit.put(`/api/v1/mentions/${mentionId}/comment`);
  return response.data;
}

async function updateMentionStatus(mentionId) {
  const response = await mentionkit.post(`/api/v1/mentions/${mentionId}`, {
    commentStatus: 1,
  });

  return response.data;
}

async function recordPostingReceipt(receipt) {
  const path = "./posted-mentions.json";
  let items = [];

  try {
    const raw = await fs.readFile(path, "utf8");
    items = JSON.parse(raw);
  } catch (error) {
    items = [];
  }

  items.push(receipt);
  await fs.writeFile(path, JSON.stringify(items, null, 2));
}

async function getCandidates(projectId) {
  const mentions = await listMentions(projectId);
  const results = [];

  for (const mention of mentions) {
    if (!isUsefulMention(mention)) {
      continue;
    }

    const mentionWithComment = await generateComment(mention.id);

    results.push({
      id: mentionWithComment.id,
      platform: mentionWithComment.platform,
      relevance: mentionWithComment.relevance,
      text: mentionWithComment.text,
      comment: mentionWithComment.comment,
      sourceUrl: mentionWithComment.url,
    });
  }

  return results;
}

Final take

For this workflow, the answer is yes: Openclaw can automate the user’s already-open, already-signed-in browser tabs for Reddit, X, and LinkedIn by attaching to the real Chrome session through the user profile, listing and focusing tabs, and then performing click/type/press actions.

But the cleaner setup is to keep Mentionkit as the source of mention truth, use commentStatus: 1 as the handled flag, and store the exact posting receipt in your own local log because the current Mentionkit status endpoint does not document arbitrary extra metadata fields.

Receive event notifications from your nodejs backend

Shash — Tue, 11 Mar 2025 07:24:50 +0000

While building products, there are many times where you need to get notified of a json payload, env vars in production, webhook data, etc.

Unfortunately, most notification tools are designed for simple user-to-user tasks.

In comes Operational, a Event tracker tool. With this tool, pass json, structured json, image urls and more in your events and get notified in the webapp or on your mobile.

Let's get started.

Sending your first event

Signup to Operational.co and get your API token
Install the Operational SDK

import Operational from "@operational.co/sdk"

Then paste this code in your project. Replace the TOKEN with your API key.

const ops = new Operational("TOKEN");

await ops.events.ingest({
  name : "User trial ended",
  avatar : "🤔"
});

That's it!

Taking it further

Now let's try sending a large javascript object to operational. This could be useful for getting notified of Stripe webhooks, 3rd party API webhooks, etc.

Run this code:

const webhookData = {
}
await ops.events.ingest({
  name : "User signed up",
  avatar : "🤔",
  type : "json",
  content : {
    user_name : "Shash",
    email : "shash@operational",
    id : 13760
  }
});

Contextual events

Sometimes, it is helpful to chain events together.

This is super helpful for understanding complex workflows, cronjobs and other scenarios. This is what Operational calls contextual events.

Here’s how you can setup contextual events:

/*
 * Set a unique Id to chain events together.
 * We will use this id for related events later
 */
const contextId = "user-12312-signup";

// First event
await ops.events.ingest({
  name : "User signup",
  avatar : "🤔",
  contextStart : true,
  contextId : contextId,
  actions : [
    {
      key : "Ban",
      url: "https://xyz.com/webhook/ban",
    }
  ]
});

// second event some time later
await ops.events.ingest({
  name : "User activated",
  avatar : "😁",
  contextId : contextId,
});

// third event
await ops.events.ingest({
  name : "User created their project",
  avatar : "👍",
  contextId : contextId,
  content : "Project Operational created for user Shash"
});

As long as the contextId is same, all these events will show up in the ‘chain’.

Conclusion

I hope this guide has been helpful for you. Let me know in the comments how you're using Operational to track events in your own backend!