Iterable MCP, plus public social data for audience segments
Iterable shipped a hosted MCP on 2026-11-12. Build journeys in Claude, then in the same turn pull public posts and comments with everyinfra_* to set segments.

Iterable shipped a hosted MCP server on November 12, 2026. It was the headline of its Winter Product Launch. Marketers can now build journeys, preview emails and check campaign performance inside Claude, ChatGPT and Cursor (Iterable product page; BusinessWire release, 2026-11-12). That server works on the customer data in your own Iterable account. It does not pull public social.
At 2026-11-17 00:19 Singapore time we added EveryInfra's everyinfra_* tools to the same client. One tiktok/search call returned 10 winter-skincare videos for $0.000556. One xiaohongshu/search call returned 20 notes for $0.005556. We fed those public posts and comments into segmentation and copy in the same chat. Six real calls in this article cost $0.013558 in total.
You build the journey on one side of a chat window. You pull public social signal on the other side. A few things then need to be clear. The first is how the two servers divide the work.
They cover how to add everyinfra_* to Claude, ChatGPT or Cursor. They cover one real round-trip, how comments become segments, the cost, and the limits. Every Iterable feature is sourced to the official launch pages with dates. Every EveryInfra number comes from a real call and reconciles against the billing field.

Two MCP servers, two jobs: your customer data and other people's public posts
The split between the two servers is the premise for every step below. Iterable's hosted MCP connects to what lives in your own Iterable account. That means user profiles, lists, templates, journeys and campaign performance. Its requests run through Iterable's Nova Agent. So when you say "list my worst-performing campaigns from last week," it reads real data from your account (Iterable product page).
That server will not scrape a Xiaohongshu note or a TikTok comment. It cannot see public social outside your account.
EveryInfra is a second MCP. It covers the half Iterable cannot reach: public posts, comments, products and charts on public platforms. It exposes 12 tools, with everyinfra_call_api at the core. Behind it sit 106 platforms and 574 data capabilities (EveryInfra catalog, read 2026-11-17). Both servers speak the Model Context Protocol.
Both can be added to the same MCP-capable client. But each uses its own auth and returns its own data, and neither fetches for the other. You put them in one conversation for one reason. Marketing needs to see who is on your list and what people outside are saying. The catalog spans overseas platforms and Chinese ones like Xiaohongshu and Douyin.
That helps cross-border brands, because the same concern reads differently on each platform.
Here is the scenario this article reuses. A skincare DTC brand wants a winter win-back journey. It wants to segment dormant users by skin concern, then write a different opening for each group. Your purchase and open history lives in Iterable. But "what the user is worried about" lives on public platforms.
Some ask whether sensitive skin can use the product. Some only ask about price and the link. You read the first with the Iterable MCP. You read the second with xiaohongshu/comments and tiktok/comments. The two line up in the same turn.
A natural prompt order makes this concrete. First the model uses everyinfra_call_api to search a topic and pull comments. It groups them into three to five concerns. Then it turns each group into one segment condition and one email opening. Then it switches to the Iterable tools to build the list and stage the journey draft.
The model goes from "what people say out there" to "how to split and speak to my own list" in one turn. It never switches between back offices.
This combination solves an old problem: where segment rules come from. Segmenting by open rate or purchase count gives you "active versus dormant." It does not give you "worried about what." Concern lives only in what people say. Public comments are the cheapest first-hand source of it. EveryInfra pulls that layer of speech back in a structured form. Iterable lands the finished segments on a real list.
Each server does the half it is good at. The walk-through below uses the winter-skincare scenario, and every number comes from this round of real calls.
Put "segment by behavior" and "segment by speech" side by side. By behavior you split users into opened-in-30-days and not. But both piles hold people who complain about dryness and people who complain about oiliness. The same "winter skincare" email lands about the same on both. By speech you first learn the five concerns in this category.
They are hydration, price, acne, ingredients and sensitivity. Then you go back to your account. You approximate each concern with existing fields like "bought a moisturizer" or "added to cart but did not pay." Now each opening speaks to its own pain point. The former cuts people by state. The latter cuts them by what they want.
For win-back the latter usually reads and clicks better. The opening lands on the reason the person did not buy. Public comments supply the "what they want" layer. Account fields supply the "does this person qualify" layer. You need both.
This path has a hard edge, covered in the limits section. The people in public comments are not the people on your list. So comments tell you roughly how many concerns a category has. They tell you what each concern cares about. They do not tell you which concern your specific user belongs to.
That still rides on their behavior in your account. Conflating the two is the easiest mistake in this method.
What Iterable shipped on 2026-11-12: hosted MCP, AI-assisted SDKs, Integrations Hub
The Winter Product Launch has three parts, all dated November 12, 2026. The headline is the hosted MCP server. Requests from Claude, ChatGPT and Cursor run through Nova Agent. It can build and stage journeys, preview and proof emails, and check campaign performance. The journey canvas and email preview render right in the chat (Iterable product page; BusinessWire release).
The second part is AI-assisted SDKs. They bring version-specific guidance for iOS, Android and React Native. The third part roughly triples the Integrations Hub. It adds HubSpot, Stripe, Chargebee, Recurly, BigCommerce, TikTok Ads and more (2026 Release Notes).
The Integrations Hub part is directly relevant to segmentation. Stripe and Recharge bring subscriptions, charges and renewals into user profiles. A failed charge can then trigger a win-back journey on the spot. On the advertising side, new syncs push audiences to Reddit Ads, Snapchat Ads, Microsoft Advertising and ChatGPT Ads. They use hashed emails.
Marketers can add or suppress ad audiences inside a journey (TechEdgeAI report, per Iterable's announcement). In other words, Iterable keeps wiring in more in-account events. But those are still in-account signals. How people outside your account talk still needs a second server.
The Winter release also adds an AI email-summary preview. Before you send, you see how an inbox AI might summarize your email. You revise if the main message gets buried. That underscores a point too. Whether copy works increasingly turns on how others read it. Public comments are a ready sample of how others read this kind of product.
The AI-assisted SDK part is not directly about pulling public data. But it makes a point that is useful when wiring up MCP. It brings version-specific guidance for iOS, Android and React Native. In Claude Code, Cursor and Codex it helps a developer reach a verified first message in under an hour. Iterable stresses one thing.
Code compiling is not the same as an integration running correctly on a real device. So the guidance walks you through to an actually-sent message (TechEdgeAI report). The same judgment applies on the data side. A 200 response does not mean the data is right. That is why every step here reads billing and the return fields.
Iterable also says developers still review the generated code themselves. They handle sensitive steps such as API-key generation and app registration. An AI tool speeds the gatekeeping; it does not remove it.
Iterable's product page quotes one customer worth noting. A team has 40 million users across 14 languages. Localizing a campaign used to mean sending English to translators and pasting translations back. That took days. With Iterable MCP they ask Claude to localize a campaign.
It pulls from Iterable, localizes language by language, confirms terminology and pushes back. That takes about two minutes (Iterable product page). That kind of work is what Iterable MCP is good at. It acts on your own data. This article fills in the other half.
In the same turn, it pulls outside concerns from public platforms too.
Hosted and self-hosted are two different things. That changes how you wire up EveryInfra. Iterable first shipped an open-source self-hosted MCP on 2025-11-19. It runs on your own machine with a personal API key. It calls the Iterable API directly (Iterable/mcp-server README).
The hosted version is run by Iterable. It installs from each client's connector directory. Each person signs in with their own Iterable account, including corporate SSO. The agent is limited to that person's permissions. There are no shared keys to manage.
Both remain. Teams use the hosted version for convenience. Developers keep the self-hosted version for direct API access.
Keep the timing straight. The announcement is 2026-11-12. But the full Winter release reaches customer accounts around 2026-12-02, per Iterable's product community. The hosted MCP is available earlier as a trial through account representatives (TechEdgeAI report). So this is a launch plus a rollout.
Not every capability is generally available that day. The "adding EveryInfra" part here does not depend on Iterable's connector reaching your directory. It holds with the self-hosted version and any MCP-capable client.
| Item | Iterable hosted MCP | Iterable self-hosted MCP |
|---|---|---|
| Sign-in | Your Iterable account, SSO supported | Personal API key |
| Runs where | Managed by Iterable | Your machine, installed from GitHub |
| Requests through | Nova Agent | Direct Iterable API calls |
| Install | Each client's connector directory | npx @iterable/mcp |
| Shipped | 2026-11-12 announcement | 2025-11-19 open source |
The self-hosted version's permission switches are spelled out. That matters for a marketing account. It is read-only by default, with no PII, no writes and no sends. Enabling writes and sends needs --advanced at setup. The README warns about the risk.
Enabling them lets the agent message real users and delete data. So you must review each step (Iterable/mcp-server README, permissions). EveryInfra reads public data only. It touches none of your users and has no such risk. But the budget is on you to control, which the costs section covers.
Add everyinfra_* to the same client: Claude, ChatGPT, Cursor
EveryInfra's remote MCP endpoint is https://api.everyinfra.com/mcp. It uses Bearer auth with one API key. It does not interfere with Iterable's connector. Run both in the same client. The conversation can then call Iterable's tools and everyinfra_*. The three clients add it slightly differently, all from their own settings.
In Claude, open Settings, then Connectors. Choose Add custom connector. Enter a name and the server URL. Complete auth when prompted (Claude custom connectors doc). In ChatGPT, turn on developer mode in settings.
From Connectors, choose Add custom MCP server. Enter a name and URL (OpenAI help center). In Cursor, manage MCP servers from the Customize page or the config file (Cursor MCP). The Model Context Protocol has a general guide to connecting remote servers too (Connect to remote MCP Servers).
| Client | Entry | Add a custom MCP | Doc |
|---|---|---|---|
| Claude | Settings → Connectors | Add custom connector, enter URL, pass auth | support.claude.com |
| ChatGPT | Settings → developer mode → Connectors | Add custom MCP server, enter name and URL | help.openai.com |
| Cursor | Customize page or config file | Add an MCP server, enter URL | cursor.com/docs/mcp |
| mcpServers clients | Config file | Write both servers | modelcontextprotocol.io |
Does your client read a mcpServers JSON config? Claude Desktop, Cursor and many MCP clients do. Then just write both servers. Expand the key from an environment variable and keep it out of the file:
{
"mcpServers": {
"iterable": {
"command": "npx",
"args": ["-y", "@iterable/mcp"]
},
"everyinfra": {
"type": "http",
"url": "https://api.everyinfra.com/mcp",
"headers": { "Authorization": "Bearer ${EVERYINFRA_API_KEY}" }
}
}
}In Claude Code, add the remote MCP as a one-line project-scoped command. A team then shares one config and each person keeps their own key:
claude mcp add --transport http everyinfra https://api.everyinfra.com/mcp \
--scope project --header "Authorization: Bearer ${EVERYINFRA_API_KEY}"After that the conversation gains new tools. They include everyinfra_list_capabilities, everyinfra_call_api and everyinfra_get_job. With both servers present, the model decides which to call. "How many users have been dormant more than 60 days" goes to Iterable. "What are people complaining about under winter dry skin" goes to everyinfra_call_api.
Put both sentences in one turn. The model can then set the segment rule from public signal, then build the list in Iterable. With many tools, the model occasionally picks the wrong server. For a fetch-only task, give EveryInfra only two tools. Keep everyinfra_call_api and everyinfra_get_job, in a client that supports a tool allowlist.
That saves conversation space and removes one chance to pick wrong. Clients differ on how to allow MCP tools. For Claude Code see the MCP doc and permissions doc.
What one turn looks like in the chat
Put this work in one turn. It runs roughly like this, each step matching a real call. The marketer types a request. "I do skincare and want to segment dormant users by winter concern. First see what people say under winter dry skin, group it, then write one win-back opening per group." The model first calls everyinfra_call_api for xiaohongshu/search.
It gets 20 notes. It notices the second note is not the most-liked but has 2,121 comments. It picks that note to pull comments. It calls xiaohongshu/comments once and gets 15. It sees lines like "can sensitive skin use this" and "I have dry skin and it is very hydrating" (translated from Chinese).
To avoid one platform, it also calls tiktok/search and tiktok/comments. It pulls 20 comments from the top video. That reaches 35 in all.
The model then groups the 14 clear ones into five concerns. It reports back. Dry/hydration 5, price 4, acne/oily 2, ingredient 2, sensitive 1. The other 21 are authenticity checks, generic praise and chatter, left out. Each group comes with a line or two of quotes. The marketer agrees.
They say "write one opening per group, with conditions on fields I have in my account." The model turns each concern into a segment condition plus a line of copy. That is the table further down. The marketer then says "switch to Iterable, revise the first win-back email for the dry/hydration group, save as draft." The model calls Iterable's tools to build the segment and edit the template. It stops before sending. The whole thing never leaves the chat window.
When sort was wrong once, the model read the 422 did_you_mean and resent.
The four EveryInfra calls in this walk-through are real. The group counts and the quotes come from real responses. The Iterable-side actions follow the official launch pages. This machine did not connect an Iterable account to run them live. So those steps are configuration examples, not measurements.
Why go through MCP instead of writing scripts
Someone will ask a fair question. Why not just write one script to pull comments and one to call the Iterable API? You can. But inside an AI tool for marketing, MCP is cheaper in two places. One, the model decides which to call and what parameters to fill.
You give it a two-part request in one sentence. It calls everyinfra_call_api and the Iterable tools separately and splits the work into steps. When a parameter is wrong, it fixes it from the 422 did_you_mean. A script does not give that flexibility. Two, both servers hang off the same client over the same protocol.
Auth, tool discovery and call format all follow the MCP spec. Swapping the client keeps the config nearly identical. There is no per-tool glue to rewrite. On 2026-11-14 we checked the three clients' setup. The entries differ.
But each adds "one server URL plus one key."
MCP is not always better than a script. Some jobs suit a script calling REST directly. A fixed large batch is one. Precise control of concurrency and retries is another. So is writing results into your own database.
There everyinfra_call_api sits on the same POST /api/v1/social and the same billing as MCP. So script and chat mix freely. Scout and decide in the chat. Run the volume in the script. Iterable leaves both paths open too.
The hosted MCP is for marketers in the chat. The open-source self-hosted version and the direct API are for developers (Iterable/mcp-server README).
One real MCP round-trip: what the model sent, what the API returned
First the handshake. At 2026-11-17 00:20 Singapore time we sent initialize to the endpoint. It returned 200, protocol version 2025-06-18 and serverInfo EveryInfra. There was no Mcp-Session-Id header. So the server does not require a session ID.
The initialize result also carried instructions for the model. In short, when the goal is vague, ask which platform, what to look up, how many results and the budget. Then recommend one to three capabilities. We then sent notifications/initialized. It returned 202 with an empty body.
We sent tools/list. It returned 200 and 12 tools. These steps follow the MCP lifecycle and the Streamable HTTP transport (MCP lifecycle spec; transport spec).
| Step | Method | Status | Note |
|---|---|---|---|
| 1 | initialize | 200 | protocol 2025-06-18, no Mcp-Session-Id |
| 2 | notifications/initialized | 202 | empty body |
| 3 | tools/list | 200 | 12 tools, 16,353 bytes |
| 4 | tools/call (everyinfra_call_api) | 200 | 15 comments, charged $0.005556 |
At 2026-11-17 00:24 Singapore time we used tools/call once. It called everyinfra_call_api for the comments on one Xiaohongshu note, with sort set to most_liked. That is the call a model would send from Claude. It returned 200. The content[0].text was a JSON string.
It parsed to 15 comments with billing.charged_usd of 0.005556. Some comments ask whether sensitive skin can use it. Some say the writer has dry skin and it is very hydrating. Some ask directly for price and link. These are the verbatim lines used to set segments.

These 12 tools fall into three groups. The table below lists them. Audience segmentation needs only the first two or three. The rest are unused here. That is why the allowlist suggestion keeps only everyinfra_call_api and everyinfra_get_job.
Tool names everyinfra_* are add-only. Old names stay callable. So writing them into scripts or prompts is safe.
| Group | Tools | Used here |
|---|---|---|
| Fetching | everyinfra_call_api, everyinfra_get_job, everyinfra_list_capabilities, everyinfra_search | yes, first two or three |
| Account | everyinfra_get_account, everyinfra_list_requests, everyinfra_get_topup_link | no |
| CAPTCHA / tickets / chat | everyinfra_solve_captcha, everyinfra_list_captcha_types, everyinfra_create_ticket, everyinfra_get_ticket, everyinfra_chat | no |
The tool list also sets how much conversation space the server takes. The whole tools/list is 16,353 bytes. That is about 4,088 tokens at roughly 4 bytes per token. One everyinfra_call_api definition is 1,804 bytes, about 451 tokens. Say your client supports a per-server tool allowlist.
Keeping only the two fetch tools saves the descriptions of the other 10. The figure below puts a few byte counts side by side.
One xiaohongshu/search raw return is 35,482 bytes. Compact each note into six fields. Those are title, likes, comments, saves, URL and is-video. It then drops to 5,245 bytes. The model's job is to set segments.
It does not need each note's cover image and author avatar. Those are signed, long CDN links. So let the conversation take only the compact summary, not the raw return. That saves most of the space, about 6.8x. In practice, have the search tool take only the fields you need.
Or let a fetch subtask compact the raw return before handing it back. Claude Code's cost doc explains why this is worth it. A long session resends the whole conversation on each request. So once raw data is in the main conversation, the cost lands on every later request (Claude Code cost doc). To count tokens exactly, the official token-counting endpoint is free (token-counting doc).
Set segments from public signal: three real calls, from posts to comments
Segmentation starts with one keyword search. At 2026-11-17 00:19 Singapore time, xiaohongshu/search ran a winter dry-skin query with sort set to most_liked. It returned 20 notes for $0.005556. Look at the top six by likes. The first has 39,904 likes, 32,944 saves and 628 comments.
The second has 22,568 likes but 2,121 comments. High likes do not mean many comments. The two numbers read differently. High likes mean the content is endorsed. Many comments mean people are asking underneath.
The asking is where segment clues are. So step two targets the most-commented note, not the most-liked. In the same minute, tiktok/search ran "winter skincare routine" with content_type set to video. It returned 10 videos for $0.000556. The top one had 755,800 views and 692 comments.
Comments set the segments. At 2026-11-17 00:24 Singapore time, xiaohongshu/comments pulled the comments on the most-commented note. It returned 15. At 2026-11-17 00:26 Singapore time, tiktok/comments pulled the comments on the top-viewed video. It returned 20 for $0.000556.
Group the 35 comments by keyword. 14 of them fall into five audience segments. There are 5 about dry skin and hydration, 4 about where to buy and price, 2 about acne, 2 about ingredients, and 1 about sensitivity. The other 21 are authenticity checks, generic praise or off-topic chatter, left out. The sample is only 35, from two pieces of content. So it is not a market share.
But it is enough to show one thing. Under the same topic you can separate a hydration group from a price-sensitive group. That maps to two journey openings. Hydration for the first, a promo price for the second.
Looking at both platforms surfaces a difference. The top Xiaohongshu notes for the dry-skin query are clearly skincare how-tos. The comments ask about ingredients, sensitive skin and price. That is a research lean. The top TikTok video had 755,800 views and 692 comments.
Its comments ask more "where do I buy this." That is a ready-to-buy lean. The same concern reads differently on the two platforms. So the journey opening for each market should differ too. That is why mixing one market's concerns into another's is a mistake. The two search prices are worth noting.
tiktok/search is $0.000556 a call and xiaohongshu/search is $0.005556. They are about 10x apart. So scout on the cheaper platform first, then pull precisely on the pricier one.
| Platform | Search price / call | Top piece | Comment lean |
|---|---|---|---|
| Xiaohongshu (dry-skin query) | $0.005556 | note: 39,904 likes, 32,944 saves | ingredients, sensitive skin, price |
| TikTok (winter skincare routine) | $0.000556 | video: 755,800 views, 692 comments | where to buy, which products |
These three calls return fields that match the catalog's response_fields. xiaohongshu/search returns title, like_count, comment_count, collect_count, author_is_verified and is_video. xiaohongshu/comments returns text, like_count, ip_location and sub_comment_count. tiktok/comments returns text, like_count, reply_count and is_reply. The capability pages are xiaohongshu/search, xiaohongshu/comments, tiktok/search and tiktok/comments.
The platform overviews are at Xiaohongshu data API and TikTok data API. For a fuller walk from search to note to comments, see Xiaohongshu data collection: search, notes, comments.

| Call | Time (SGT) | Capability | Params | Returned | Charged |
|---|---|---|---|---|---|
| 1 | 00:19 | tiktok/search | keyword winter skincare routine, content_type video | 10 videos | $0.000556 |
| 2 | 00:19 | xiaohongshu/search | winter dry-skin query, sort most_liked | 20 notes | $0.005556 |
| 3 | 00:24 | xiaohongshu/comments | one note URL, sort most_liked (via MCP tools/call) | 15 comments | $0.005556 |
| 4 | 00:26 | tiktok/comments | top-viewed video URL | 20 comments | $0.000556 |
| 5 | 00:21 | youtube/search | keyword iterable mcp server | 10 videos | $0.000778 |
| 6 | 00:21 | youtube/transcript | Iterable official video | transcript (promo is music only) | $0.000556 |
Turn comments into segment rules and opening copy
Translating this step is where a human judges. The API cannot help here. Behind "can sensitive skin use this" is a wary group. They will not try new products freely. So the opening should lower the barrier to trying.
Behind "where to buy, how much" is a group already won over. They are stuck on price or the purchase path. So the opening should give certainty. Put the same comment in the wrong group and the email reads backwards. Grouping is not just counting keywords.
It is reading where the writer got stuck. So this step takes a human nod, not a one-click apply.
The table below is built from the 14 classified concerns in this round's 35 comments. Segment conditions land in Iterable on fields you already have. Openings are written to the tone of the concern. The groups match the five in the chart above.
| Audience group (from comments) | This sample | Segment condition (land on Iterable account fields) | Journey opening |
|---|---|---|---|
| Dry / hydration | 5 | Bought a cream or lotion, no open in 60 days | "Skin tight from the cold? Lock in hydration first." |
| Where to buy / price | 4 | Added to cart unpaid, viewed a promo page | "The one you eyed has a promo price this week." |
| Acne / oily | 2 | Bought a cleanser or oil-control item | "Oily even in winter? Hydrate light, two steps together." |
| Ingredient / efficacy | 2 | Viewed an ingredient page or a long guide | "What is in it and what it fixes, in one read." |
| Sensitive / barrier | 1 | Bought the sensitive-skin line | "Barrier stressed? Skip strong actives, repair gently." |
Two points here. First, public comments set which groups and what to say. Landing on the list still uses your account fields. You cannot pad your own list with public users. They are not the same crowd.
Second, be honest about the sample. There are only 35. The openings above are examples in the tone of those 35. They are not copy validated by sending. To treat it as a firm basis, broaden the keywords.
Pull dozens to hundreds of comments. See whether each group's share holds. The method and cost are in the costs section below. For a full approach that keeps raw data in a subtask, see parallel Claude Code subagents pulling brand accounts.
What else the fields can split: not just concern
Concern is the most direct layer. But a few return fields help you segment finer. xiaohongshu/comments carries ip_location, the commenter's region. For winter skincare, northern and southern pain points differ. So when one concern clusters in a region, you get a regional opening for free.
All 15 comments this round had an empty ip_location. So the field is not always present and cannot be assumed. But it is a free clue when it is there. author_is_verified separates brand accounts from ordinary users. To set concern you want ordinary users' words.
A comment with a large sub_comment_count tends to be the one that landed. Following its replies (xiaohongshu/sub_comments, needs the comment id) shows a string of similar follow-ups.
| Field | On | What it splits |
|---|---|---|
ip_location | xiaohongshu/comments | region (empty in all 15 this round) |
author_is_verified | search / comments | brand account vs ordinary user |
sub_comment_count | xiaohongshu/comments | which comment landed, follow its replies |
is_video | xiaohongshu/search | image-text vs video content format |
collect_count vs comment_count | xiaohongshu/search | "save to do later" vs "arguing underneath" |
The note-side fields help too. xiaohongshu/search's is_video separates image-text from video. To copy a content format, see which gets more likes and saves. This round the top six were two image-text and four video. The first, an image-text note, has 32,944 saves.
That is far above its 628 comments. So it is a saved-for-reference how-to. Comments under that kind lean toward "where to buy." The ratio of collect_count to comment_count shows the content's nature. Saves far above comments means "saving to do later." Comments far above saves means "arguing underneath." The latter has more segment clues in its comment section. Stack these with concern.
You go from five concerns to a more specific group, like "northern dry skin, saving to do later." The sample must be large, though. 35 is not.
Errors self-heal: 422 with did_you_mean, no charge
The first Xiaohongshu search had sort written as popularity. The API returned 422 with code invalid_value. The message listed all five allowed values. They are most_collected, most_commented, most_liked, newest and relevance. The did_you_mean was set to most_liked.
The next_steps said to change only sort and resend, and that nothing was charged. That return is written for the model. It does not just say the parameter is wrong. It gives a directly usable next step. A client like Claude self-heals by changing one value.
We changed it to most_liked, resent, and got 200 with 20 results. For an agent in a conversation this matters. It does not stall or overspend because one parameter name is wrong. It reads did_you_mean, changes it once, and continues.

Rate limiting is the other return to handle. This test key is capped to 10 requests per minute. Several clients share it. At 2026-11-17 00:20 Singapore time we hit one 429. Its message states 10 per minute and to retry in a few seconds.
A 429, like a 422 or 401, happens before any charge. So it is safe to retry. Wait the stated seconds and resend. Do not hammer in parallel. The HTTP spec defines 429 as too many requests in a given time.
The response can carry a Retry-After to say how long to wait (RFC 6585; RFC 9110). The setup notes are at remote MCP setup. The three REST steps are at quickstart.
Page and async: pull a note's comments in full
The xiaohongshu/comments call above returned only 15. It returns one page at a time. The return carries next_page_token. Put it in the next request's page_token to keep going. The most-commented note has 2,121 comments.
Pulling it in full takes many pages. Each page is a call at $0.005556. So pulling a hot note in full is not cheap. That is why the advice is to pull only the most-commented few. Reading the catalog on 2026-11-16 confirmed the optional params.
They are page_token and sort. The sort value supports most_liked, most_commented, newest and two others. That matches the allowed values in the 422 return.
To pull a lot at once, use async. Any capability can run async. Add {"mode":"async"} to the POST /api/v1/social body. You get a 202 and a job_id immediately. Then poll everyinfra_get_job, which is GET /api/v1/jobs/{job_id} in REST.
Reading a job is not charged. In the chat, the model can submit a batch of slow tasks. It collects a string of job_id values. It reads results one by one. It does not wait on any single comments return.
Here is the REST for the second page. The key is read only from an environment variable:
curl -s https://api.everyinfra.com/api/v1/social \
-H "Authorization: Bearer $EVERYINFRA_API_KEY" \
-H "Content-Type: application/json" \
-d '{"platform":"xiaohongshu","action":"comments","params":{"url":"...note...","page_token":"...","sort":"most_liked"}}'Do the math: by call count, independent of the model
The EveryInfra side's cost depends only on call count. It does not depend on how many rows come back or which model runs. The price gap is mostly by platform. TikTok and YouTube capabilities are cheap. Xiaohongshu is about 10x pricier. The figure below is the per-1,000 price for several capabilities.
| Scale | Makeup | Calls | Cost |
|---|---|---|---|
| One segmentation study (this article) | 2 searches + 2 comment pulls + 2 YouTube gap checks | 6 | $0.013558 |
| One topic, weekly, a month | 6 calls each time | ~24 | ~$0.054 |
| 10 topics, weekly, a month | 6 calls each time | ~240 | ~$0.543 |
| 100 notes, comments each (Xiaohongshu) | 100 xiaohongshu/comments | 100 | $0.5556 |
This table assumes you pull only the few you need. There are two ways to save. First, use one search to pick the few most-commented notes. Then pull comments on those, not every note found. Second, move slow tasks or large limit values to async.
Use {"mode":"async"} for a job_id and everyinfra_get_job to read, which is not charged. Take the winter-skincare topic. Say you watch one keyword a week. You pull comments on the three most-commented. That is 1 search plus 3 comment pulls, about $0.022 a run.
That is under $0.09 a month for four runs. Watch ten categories and it is about half a dollar a month. Iterable's hosted MCP has no separately announced price. It follows your existing Iterable plan and each person's permissions. The self-hosted version is free (TechEdgeAI report, per Iterable's announcement).
Confirm specifics with your Iterable account team. Our own key spent $0.013558 total for this article. The detail reconciles against each return's billing. See the market catalog and pricing page.
Make one study a weekly watch
Beyond the single study, think one layer up. Segment rules are not set once and fixed. Season change, launches and a competitor's promotion all shift what a category cares about. A steady approach is to fix the above into a weekly task. Each Monday, search each keyword you watch.
Pull comments on the most-commented two or three. Group them into the five concerns' counts. Compare to last week. Whichever rose tells you which opening to adjust. The cost is small enough to leave running, with the exact numbers in the math section below.
This can run apart from the journey itself. Concern research uses EveryInfra. It produces a small table of this week's counts per concern and a few quotes. Journey tuning uses the Iterable hosted MCP. The marketer holds that table and says in Claude "revise the first win-back opening to the concern that rose most this week." Around 2026-11-11 several outlets covered the same shift.
Marketing AI is moving from "handy for one person" to "a team and its agents sharing the same data and permissions" (MarTechCube report). Making public-signal research into a weekly table is how it goes from one person's craft to a shared input.
To make this an unattended scheduled task, a few engineering things remain. Comments must be deduplicated, since the same comment can repeat across pages (dedupe by id). The grouping keywords change by category. Skincare's "barrier" and "exfoliate" become other words elsewhere. Each week's numbers must land in a comparable table, not only the current week.
These are out of scope here. But they all follow from remote MCP setup and the field notes on the capability pages.
Limits: what this combination cannot get
This combination has a few things it cannot get. First, the sample is small. The 35 comments here are from two pieces of content. They show only that groups are separable. They do not show each group's share.
Estimating shares means broadening keywords to dozens or hundreds of notes. That scales up the cost in the table above. Second, fields have limits. xiaohongshu/comments returns one page with a next_page_token. More comments mean paging, each page a call.
Xiaohongshu comments do not guarantee a full reply tree. Third, public data is public data, not the people on your list. EveryInfra pulls anyone's public posts on a platform. Iterable holds your own users. The two are not the same crowd and cannot be merged.
Public signal only guides the segment rule. Fourth, the YouTube line found nothing to add this time. The gap check had one relevant video, Iterable's official 2025-11-19 MCP promo. Its footage is music only. There were no demo steps to write.
One Iterable-side limit is worth keeping in mind. With the self-hosted MCP's send permission on, creating a blast campaign schedules it for delivery. That follows the Iterable API's behavior. There is no "draft campaign" concept. To only draft content, leave send off and use templates (Iterable/mcp-server README).
Feeding EveryInfra's public signal into copy is the read-only, safe half. The step that actually messages users keeps its permissions and review on the Iterable side. That is on you. A safe order helps. Have the agent stage the journey as a draft and stop before sending.
Review the canvas in Iterable before going live. Treat the first two weeks as a trial run.
Two more things to settle up front. One, match platform to language. Xiaohongshu is a Chinese skincare topic. It fits segmenting a Chinese-market journey. To segment an English-market journey, search English terms on tiktok/search.
Do not map one market's concerns onto another. Two, timing. Comments are of the moment, and segment rules drift. So this suits running periodically and regrouping each time. It does not suit running once and hardcoding a constant.
EveryInfra gives only the public data and its fields. How to group, how often to run, and which account fields to land on are your calls.
Which three steps to try first
To get started you need not wire up Iterable at once. You can take just EveryInfra for three steps. They show whether it is worth it.
| Step | Do | Cost |
|---|---|---|
| 1 | everyinfra_list_capabilities or read the catalog; confirm platforms, names, prices | free |
| 2 | Search one keyword, pull comments on the most-commented few, group into concerns | ~$0.022 |
| 3 | Hand-revise one win-back opening from a group's verbatim lines; judge it | free |
Step one confirms the platforms, capability names and prices you care about. Step two searches one keyword you care most about. It pulls comments on the most-commented two or three and groups them into concerns. Then you see whether the groups give you more to say. Step three takes a few verbatim lines from one group.
You hand-revise a win-back opening and judge it yourself. These three steps cost under three cents a run. They touch no Iterable account. You then decide whether to wire it into the journey. If the groups are no better than your behavior split, the category's public talk is thin.
Change the keyword or platform and try again. If you plainly see two or three groups speaking differently, wire it in and run weekly. The three REST steps are at quickstart. How to attach MCP in each client is at remote MCP setup.
Industry notes
- 2026-11-12, Iterable shipped the hosted MCP server, AI-assisted SDKs and a tripled Integrations Hub (Iterable product page). For marketing teams, building journeys inside AI tools becomes a team capability, not one person's skill.
- 2026-11-12, Iterable's release states the hosted MCP uses each person's own Iterable login including SSO, with no shared keys (BusinessWire release). So permission auditing matters more, since what a marketer can do, their agent can now do faster.
- 2026-11-13, third-party coverage notes the Winter release has a rollout, with the full set reaching accounts around 2026-12-02 (TechEdgeAI report). So do not read "shipped" as "available"; confirm your account has it.
- 2026-10-20, Iterable's October release added Stripe, Recharge and TikTok Ads integrations and segmentation guardrails (2026 Release Notes). So failed-charge and renewal events can trigger journeys, and public signal can follow those events.
- 2026-11-07, third parties began writing up middleware to connect Iterable to ChatGPT (Truto blog). So the ways to connect are multiplying, but auth and permission boundaries still need checking.
- The MCP spec's 2025-06-18 version defines the Streamable HTTP transport and lifecycle (MCP spec). So the remote-MCP handshake is standard and carries across platforms.
FAQ
Can Iterable's MCP pull public Xiaohongshu or TikTok data directly? No. Iterable's hosted MCP connects to the customer data in your own Iterable account. It does not scrape public social outside it (Iterable product page). For public posts and comments, attach a data MCP such as EveryInfra's everyinfra_call_api.
Can one client run both Iterable and EveryInfra MCP at once? Yes. Both speak the Model Context Protocol, each with its own auth and data. In a client that supports mcpServers, write both. The "add to the same client" section gives the config.
What is the everyinfra MCP server address and its tools? The address is https://api.everyinfra.com/mcp with Bearer auth. tools/list returns 12 tools. The core ones are everyinfra_call_api, everyinfra_get_job and everyinfra_list_capabilities. This was measured 2026-11-17 00:20 Singapore time.
How much does pulling public comments for segmentation cost? By call count. tiktok/comments is $0.000556 a call. xiaohongshu/comments is $0.005556. That is $0.556 and $5.556 per 1,000. This article's one study, 6 calls, totals $0.013558, reconciling against each return's billing.
When is Iterable's hosted MCP available, and does it cost extra? The announcement is 2026-11-12. Per Iterable's community the full Winter release reaches accounts around 2026-12-02. The hosted MCP is available earlier as a trial through account representatives. No separate price is published; it follows your existing Iterable plan, and the self-hosted version is free (TechEdgeAI report).
Will a wrong parameter overcharge me? No. An invalid parameter returns 422 with did_you_mean and the allowed values, and no charge. A rate limit returns 429 with no charge. At 2026-11-17 00:19 Singapore time we wrote sort wrong. The return said "nothing was charged." Changing one value and resending worked.
Can I pad my Iterable list with public users? No, and you should not. EveryInfra pulls anyone's public posts on a platform. They are not the same crowd as your Iterable users. Public signal sets only how many groups and what each cares about. Landing on the list still uses your account fields.
References
- Iterable, "Explore Iterable's Latest Platform Innovations & Updates," iterable.com, 2026-11-12, <https://iterable.com/product/whats-new/>
- Iterable, "What's New at Iterable: Winter Product Launch 2026," events.iterable.com, 2026-11-12, <https://events.iterable.com/whats-new-at-iterable-winter-product-launch-2026/>
- BusinessWire / Yahoo Finance, "Iterable Opens Its Platform to Claude, ChatGPT, and Cursor With a Hosted MCP Server," 2026-11-12, <https://finance.yahoo.com/technology/ai/articles/iterable-opens-platform-claude-chatgpt-140000056.html>
- Iterable, "2026 Release Notes," support.iterable.com, 2026-10-20, <https://support.iterable.com/hc/en-us/articles/44900665796628-2026-Release-Notes>
- Iterable, mcp-server README, GitHub, <https://github.com/Iterable/mcp-server/blob/main/README.md>
- Iterable, mcp-server repository, GitHub, <https://github.com/Iterable/mcp-server>
- Iterable, Recharge integration, support.iterable.com, <https://support.iterable.com/hc/articles/54558473243540>
- Iterable, Stripe integration, support.iterable.com, <https://support.iterable.com/hc/articles/54550787663380>
- Iterable, TikTok Ads integration, support.iterable.com, <https://support.iterable.com/hc/articles/54559482036756>
- Iterable, Salesforce integration, support.iterable.com, <https://support.iterable.com/hc/articles/54760250284180>
- Iterable, Segmentation Reference, support.iterable.com, <https://support.iterable.com/hc/articles/29471638325524>
- TechEdgeAI, "Iterable Adds MCP Server for AI Marketing Teams," 2026-11-13, <https://techedgeai.com/iterable-adds-hosted-mcp-server-to-scale-marketing-ai/>
- MarTechCube, "Iterable Launches Hosted MCP Server for Claude, ChatGPT and Cursor," 2026-11-12, <https://www.martechcube.com/iterable-launches-hosted-mcp-server-for-claude-chatgpt-and-cursor/>
- Truto, "Connect Iterable to ChatGPT," 2026-11-07, <https://truto.one/blog/connect-iterable-to-chatgpt-manage-campaigns-and-user-profiles/>
- Anthropic, "Get started with custom connectors using remote MCP," support.claude.com, <https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp>
- Anthropic, Claude Code MCP doc, code.claude.com, <https://code.claude.com/docs/en/mcp>
- Anthropic, Claude Code subagents doc, code.claude.com, <https://code.claude.com/docs/en/sub-agents>
- Anthropic, Claude Code cost doc, code.claude.com, <https://code.claude.com/docs/en/costs>
- Anthropic, Claude Code permissions doc, code.claude.com, <https://code.claude.com/docs/en/permissions>
- Anthropic, pricing page, platform.claude.com, <https://platform.claude.com/docs/en/about-claude/pricing>
- Anthropic, token-counting doc, platform.claude.com, <https://platform.claude.com/docs/en/build-with-claude/token-counting>
- OpenAI, "Connecting custom MCP servers in ChatGPT," help.openai.com, <https://help.openai.com/en/articles/12584461-connecting-custom-mcp-servers-in-chatgpt>
- Cursor, Model Context Protocol (MCP) doc, cursor.com, <https://cursor.com/docs/mcp>
- Cursor, CLI MCP doc, cursor.com, <https://cursor.com/docs/cli/mcp>
- Model Context Protocol, transport spec 2025-06-18, <https://modelcontextprotocol.io/specification/2025-06-18/basic/transports>
- Model Context Protocol, lifecycle spec 2025-06-18, <https://modelcontextprotocol.io/specification/2025-06-18/basic/lifecycle>
- Model Context Protocol, "Connect to remote MCP Servers," <https://modelcontextprotocol.io/docs/2026-07-28/develop/connect-remote-servers>
- IETF, RFC 6585 (Additional HTTP Status Codes, 429), <https://www.rfc-editor.org/rfc/rfc6585>
- IETF, RFC 9110 (HTTP Semantics, Retry-After), <https://www.rfc-editor.org/rfc/rfc9110>
- EveryInfra, data capability catalog, api.everyinfra.com, 2026-11-17, <https://api.everyinfra.com/api/v1/social/catalog>
- EveryInfra, Xiaohongshu capability catalog, api.everyinfra.com, <https://api.everyinfra.com/api/v1/social/catalog?platform=xiaohongshu>
- EveryInfra, TikTok capability catalog, api.everyinfra.com, <https://api.everyinfra.com/api/v1/social/catalog?platform=tiktok>
- EveryInfra, YouTube capability catalog, api.everyinfra.com, <https://api.everyinfra.com/api/v1/social/catalog?platform=youtube>
- Iterable, "How Iterable's MCP Server Powers Smarter Agentic Marketing," iterable.com, 2026-09-11, <https://iterable.com/blog/introducing-open-source-model-context-protocol-mcp-server/>
- Iterable, Winter 2026 Product Launch blog, iterable.com, 2026-11-12, <https://iterable.com/blog/winter-2026-product-launch/>
- Henry Moses Jr, Winter 2026 Release post, LinkedIn, 2026-11-13, <https://www.linkedin.com/posts/henrymoses_martech-aiworkflows-productlaunch-activity-7526705822693871616-0jZr>
- BusinessWire, "Iterable Launches Model Context Protocol (MCP) Server," 2025-11-19, <https://www.businesswire.com/news/home/20251119094529/en/Iterable-Launches-Model-Context-Protocol-MCP-Server-Strengthening-Its-Dominance-in-AI-Marketing-Innovation>
- Composio, Iterable MCP toolkit, composio.dev, <https://composio.dev/toolkits/iterable>
- OpenAI Agents SDK, Model context protocol (MCP) doc, <https://openai.github.io/openai-agents-python/mcp/>
- Python docs, concurrent.futures, docs.python.org, <https://docs.python.org/3/library/concurrent.futures.html>
- Improvado, Iterable MCP overview, improvado.io, <https://improvado.io/mcp/iterable>
- StackOne, Iterable MCP Server for AI Agents, stackone.com, <https://www.stackone.com/connectors/iterable/mcp/>
Reference BL-171