DEV Community: Alex

We went from 33 to 87 on Cloudflare's agent-readiness scan. Here's what each check actually does.

Alex — Sat, 31 Oct 2026 13:33:12 +0000

Cloudflare has a free scanner at isitagentready.com that grades how easy your site is for AI agents to find, read and use. We build Fuxux, a social media scheduler with a public REST API and a hosted MCP server, so I assumed we'd do fine.

We scored 33/100, Level 1 ("Basic Web Presence").

A day later we were at 87/100, Level 5 ("Agent-Native"). None of it was hard, but most of it wasn't obvious either, so here's every check that failed, what it means, and the exact thing we now serve. Two checks still fail on purpose, and I'll explain why at the end.

The starting point

Category	Before	After
Discoverability	2/4	4/4
Content	1/1	1/1
Bot Access Control	1/2	2/2
API, Auth, MCP & Skill Discovery	1/8	6/8

What we already had: a valid robots.txt, a sitemap, and Markdown versions of our pages for agents (that's the Content check). What we didn't have was any machine-readable way to say "there's an API here, and an MCP server, and this is how you sign in". We had all of those things. We just never told agents where they were.

1. Link headers on the homepage (RFC 8288)

The cheapest fix. Agents that only fetch your homepage can't find anything that isn't linked from it, and HTML links are noisy. A Link response header points straight at the useful resources:

Link: </.well-known/api-catalog>; rel="api-catalog",
      </openapi.json>; rel="service-desc"; type="application/vnd.oai.openapi+json",
      </docs>; rel="service-doc"; type="text/html",
      </.well-known/mcp/server-card.json>; rel="describedby"; type="application/json",
      </llms.txt>; rel="describedby"; type="text/plain"

We're on Next.js, so this is one entry in headers() in next.config.ts, applied to / and our translated homepages.

2. Content Signals in robots.txt

robots.txt says who may crawl. Content Signals say what they may do with it: show it in search, use it as input to an AI answer, or train on it.

User-Agent: *
Content-Signal: search=yes, ai-input=yes, ai-train=yes

This is a business decision, not a technical one. We want AI assistants to know Fuxux exists and recommend it, so everything is yes. A news site would probably answer differently.

3. An API catalog (RFC 9727)

/.well-known/api-catalog is a small JSON "linkset" listing your APIs and where their descriptions and docs live. Ours lists the REST API and the MCP server:

{
  "linkset": [
    {
      "anchor": "https://www.fuxux.com/api",
      "service-desc": [{ "href": "https://www.fuxux.com/openapi.json", "type": "application/vnd.oai.openapi+json" }],
      "service-doc": [{ "href": "https://www.fuxux.com/docs", "type": "text/html" }]
    },
    {
      "anchor": "https://www.fuxux.com/api/mcp",
      "service-desc": [{ "href": "https://www.fuxux.com/.well-known/mcp/server-card.json", "type": "application/json" }],
      "service-doc": [{ "href": "https://www.fuxux.com/mcp/docs", "type": "text/html" }]
    }
  ]
}

Serve it as application/linkset+json.

4. The MCP server card was missing one field

We already published /.well-known/mcp.json, and the scanner found it, then failed it: "missing required fields (need serverInfo.name or name)". We'd written it for one client months ago and never checked it against the draft server-card format.

We added name, version and a serverInfo block, kept every old field so nothing that read it before breaks, and also serve it at /.well-known/mcp/server-card.json:

{
  "name": "com.fuxux/mcp",
  "title": "Fuxux",
  "version": "1.3.0",
  "serverInfo": { "name": "fuxux", "title": "Fuxux", "version": "1.3.0" },
  "transport": { "type": "streamable-http", "endpoint": "https://www.fuxux.com/api/mcp" },
  "authentication": {
    "required": true,
    "schemes": ["oauth2", "bearer"],
    "protected_resource_metadata": "https://www.fuxux.com/.well-known/oauth-protected-resource"
  }
}

(Trimmed: the real one also has a description, icons and docs links.)

5. An Agent Skills index

Agent Skills are Markdown instruction files (SKILL.md) that teach an agent how to use your product. We already had two for the ChatGPT plugin and ClawHub. The discovery index just lists them, with a hash so a client can tell whether a file changed:

{
  "$schema": "https://schemas.agentskills.io/discovery/0.2.0/schema.json",
  "skills": [
    {
      "name": "social-media-posts",
      "type": "skill-md",
      "url": "/.well-known/agent-skills/social-media-posts/SKILL.md",
      "digest": "sha256:4f7590cc…"
    }
  ]
}

One gotcha: compute the digest from the exact bytes you serve. We first hashed the file before our build changed its line endings, and the digest didn't match.

6. An ARD manifest

ARD (Agentic Resource Discovery) is one catalog at /.well-known/ai-catalog.json that lists everything an agent can use on your domain: MCP servers, OpenAPI specs, agents. Each entry can carry representativeQueries, example requests the resource is good for:

"representativeQueries": [
  "schedule a post to Instagram and LinkedIn for tomorrow at 9am",
  "what posts do I have scheduled this week",
  "why did my TikTok post fail"
]

7. WebMCP: two read-only tools in the browser

WebMCP lets a page register tools that an AI agent running in the user's browser can call. It's still a draft and few browsers support it, so we kept it tiny: two read-only tools on marketing pages, one returning an overview, one returning pricing, both from Markdown we already serve.

const ctx = document.modelContext ?? navigator.modelContext;
if (!ctx || typeof ctx.registerTool !== "function") return; // most browsers today
for (const tool of TOOLS) {
  try {
    ctx.registerTool(tool, { signal: controller.signal });
  } catch {
    // an older draft of the API: leave the page alone
  }
}

No writes, no auth, nothing that can change an account. If the API changes shape, the try keeps the page working.

8. DNS for AI discovery, and DNSSEC

This one took the longest, and it isn't code. DNS-AID lets an agent find your services with a DNS lookup instead of a web request:

_mcp._agents.fuxux.com.   HTTPS 1 www.fuxux.com. alpn="h2" port=443

Adding the record took a minute. The scanner still failed it, with a precise message: "records found, but DNSSEC was not validated." A discovery record only counts if a resolver can prove it wasn't forged.

Our DNS is on Cloudflare but the domain is registered at GoDaddy, so DNSSEC has two halves:

Turn DNSSEC on in Cloudflare (DNS → Settings). It signs the zone and shows you a DS record.
Add that DS record at the registrar (GoDaddy → DNS → DS Records): key tag, algorithm 13, digest type 2, digest.

About 20 minutes later cloudflare-dns.com returned AD: true for the record, and Discoverability went to 4/4. Side benefit: the whole domain is now protected against forged DNS answers, which we should have done anyway.

The two checks we skip on purpose

OAuth Protected Resource Metadata at the root. We do serve RFC 9728 metadata, but ours names the MCP endpoint as the resource:

{ "resource": "https://www.fuxux.com/api/mcp", "authorization_servers": ["https://www.fuxux.com"] }

The scanner expects the document at the root to name the origin itself. That's a reasonable reading of the RFC. But when we submitted our connector to Claude's and ChatGPT's directories, both reviews needed resource to equal the MCP URL exactly. One scanner point isn't worth risking two live directory listings, so this stays as it is.

auth.md. This lets an agent register an account on its own, without a person going through sign-up. For a product where each published X post costs us real money, and where our abuse limits (one trial per person, email and card checks) assume a human signs up, automatic account creation is a product decision, not a checkbox. We'll revisit it when assistants actually use it.

What I'd do first if you're starting from Level 1

In order of effort versus score:

Content-Signal in robots.txt (two minutes)
Link headers on the homepage (ten minutes)
/.well-known/api-catalog if you have an API
Check any MCP server card you already publish against the current format
DNSSEC, if your DNS provider makes it one click

Then decide, deliberately, which checks you don't want. The score is a checklist, not a goal. A couple of the things it asks for change who can do what on your product, and those deserve a real decision.

If you want to try the MCP server this was all about, it's at https://www.fuxux.com/api/mcp, and the setup for Claude, ChatGPT and Cursor is at fuxux.com/mcp/docs. Questions about any of the files above are welcome in the comments.

Social Media Schedulers That Work in ChatGPT and Claude (2026)

Alex — Thu, 22 Oct 2026 21:14:55 +0000

Disclosure: Independent guide from Fuxux, which is one of the tools compared. We are not affiliated with any other tool here. Every price, plan limit and directory listing was read from the vendor's own pages, or from the Claude and ChatGPT directories, on 22 October 2026. These change quickly, so check before you buy.

A year ago, "AI social media tool" meant a caption generator. Now you can ask Claude or ChatGPT to write a week of posts, and the chat schedules them in your scheduler. That works through a connector built on MCP (Model Context Protocol), which gives the assistant a small set of tools: list your accounts, create a post, schedule it, check the queue.

Plenty of schedulers now say they "work with AI". Fewer let you connect from Claude or ChatGPT with a simple sign-in. Fewer still do it on a free plan. This guide compares ten of them on the questions that decide whether it works for you.

Quick answer: five tools let you connect Claude or ChatGPT on a free plan: Buffer, Metricool, Pallyy, Typefully and Fuxux. Their free limits differ a lot, from 5 posts a month to 10 queued posts per channel. Postiz, Post Bridge, Publer, Vista Social and Hootsuite need a paid plan for it, or have no free plan at all. Pick by the networks you post to and how the price is counted, not by the AI feature, which is now similar across most of them.

What "works with ChatGPT and Claude" actually means

There are three levels, and vendor pages often blur them:

Listed in the assistant's directory. In Claude you add it from the connectors directory; in ChatGPT, from the plugin directory. You sign in to the scheduler and approve access, with no key to copy. This is the easiest route.
A hosted MCP server you add by hand. You paste a server URL as a custom connector. This still uses a sign-in on most tools, but in ChatGPT a custom connector needs a paid ChatGPT plan.
An API key. This is for developer tools such as Claude Code or Cursor, or for automations. It is powerful, but often sits behind a higher plan or an add-on.

The questions that matter: can you connect with a sign-in, is it on the plan you can afford, which networks will it post to, and can it publish or only draft?

Comparison table

Tool	AI connection on the free plan?	Claude directory	ChatGPT directory	Cheapest paid plan	Networks
Fuxux	Yes (3 accounts, 5 posts a month, no X)	Yes	Yes	$29/mo flat, 15 accounts	14, incl. Telegram and Slack
Buffer	Yes (3 channels, 10 scheduled posts each)	Yes	Not found	$6/mo per channel ($5 billed yearly)	12
Metricool	Yes (1 brand, 20 posts a month, no LinkedIn or X)	Yes	Yes	From $25/mo ($20 yearly), up to 5 brands	11
Pallyy	Yes (1 social set, 15 posts a month, images only)	Yes	Yes	$25/mo per social set	10
Typefully	Yes (1 social set, 10 posts a month)	Yes	Not found (custom connector)	$99/yr, billed yearly only	6, text-first
Postiz	No free plan (7-day trial)	Yes	Yes	$29/mo ($23 yearly), 5 channels	30+, incl. Telegram and Slack
Post Bridge	No (MCP from the $39 plan)	Yes	Yes	$39/mo for MCP, 15 accounts	10
Publer	No (Business plan and up)	Not found	Not found	Business about $8 per social account a month, billed yearly	13, incl. Telegram
Vista Social	No (all paid plans)	Not found	Not found	$99/mo, 15 profiles	13
Hootsuite	No free plan (14-day trial)	Not found	Not found	€99 per user/mo billed yearly; plan with publishing MCP not stated	Not stated

"Not found" means we searched the directory on 22 October 2026 and the tool did not come up. Several of these tools can still be added by hand as a custom connector.

The free options

Fuxux

Fuxux is our tool, so read this with that in mind. It is listed in both Claude's connector directory and ChatGPT's plugin directory: you sign in and approve, and there is no key to copy. The connection is on every plan, including Free.

What the assistant can do: list your connected accounts, publish now, schedule, save a draft, edit or reschedule a scheduled post, list the queue and read a short dashboard of stats.
Networks: 14. Instagram, TikTok, YouTube, X, Facebook, LinkedIn, Threads, Pinterest, Bluesky, Discord, Twitch, Kick, Telegram and Slack. Telegram and Slack are rare in this list; of the free options here, only Fuxux posts to them.
Price: flat, not per channel. Free is 3 accounts and 5 published posts a month (each network a post goes to counts as one) and does not include X. Creator is $29 a month for 15 accounts and unlimited posts. An API key, for Cursor or scripts, is a $5 a month add-on on paid plans.
Weak spot: the free plan's 5 posts a month is the smallest here. It is enough to try the AI workflow, not to run a busy account.

Buffer

Buffer's MCP page says access is "included on every plan, including Free", and it connects with a sign-in. Its tools cover sharing now, adding to the queue, custom scheduling, drafts, ideas and post metrics. The free plan gives 3 channels with 10 scheduled posts each, the most room of any free option here. Paid plans are counted per channel, which is cheap for a few accounts and adds up for many. It was in Claude's directory but did not come up in ChatGPT's when we searched.

Metricool

Metricool is in both directories and connects with a sign-in on any plan, Free included. It is the strongest pick if your AI questions are about numbers: its connector covers analytics, ads accounts and best times to post as well as scheduling. The catch is the free plan: 1 brand and 20 posts a month, and its pricing page says it covers every network "except LinkedIn and Twitter".

Pallyy

Pallyy says its connector works "on every plan, free included", and it is in both directories. The assistant can create draft or scheduled posts and import images. Pallyy's own docs say it "cannot read analytics", and the free plan is 1 social set with 15 image posts a month.

Typefully

Typefully is built for writers on X, LinkedIn, Threads, Bluesky, Mastodon and Substack. Its free plan includes "Agents, API, MCP" with 10 posts a month, and it has a verified badge in Claude's directory. In ChatGPT it is a custom connector rather than a directory listing. If you mostly write text posts and threads, it is a good fit; if you post video to TikTok or Instagram, it is not.

The paid options

Postiz

Postiz covers the most networks (30+, Telegram and Slack included) and has a hosted MCP server on every plan. It is in both directories. There is no free plan: you get a 7-day trial, then plans start at $29 a month for 5 channels ($23 billed yearly). It is also open source, if you would rather host it yourself and handle each network's app approval.

Post Bridge

Post Bridge lists "MCP agent connect" on its $39 a month Marketer plan (15 accounts), and it is in both directories. Its connector has 16 tools, including media upload and analytics sync. It posts to 10 networks.

Publer

Publer's MCP is on the Business and Enterprise plans. Business is priced per social account (about $8 a month each, billed yearly, on the page we saw). It connects as a custom connector, and it was not in either directory when we checked. It does post to Telegram.

Vista Social

Vista Social's connector is "included with all paid plans" and advertises more than 100 tools across scheduling, analytics, inbox and reporting, the widest tool set here. Plans start at $99 a month for 15 profiles. It is aimed at teams and agencies.

Hootsuite

Hootsuite has separate MCP servers for publishing, inbox and listening. Its plans page lists only the listening connector, on Enterprise, so we could not confirm which plan includes publishing through Claude or ChatGPT. Standard starts at €99 per user a month, billed yearly. If you are already on Hootsuite, ask your account manager.

How to choose

If you...	Look at
Want to try it free with a few accounts	Buffer (most free posts) or Fuxux (14 networks, sign-in from both directories)
Ask your AI mostly about analytics and ads	Metricool
Post to Telegram channels or Slack along with social	Fuxux, or Postiz if you need even more networks
Write text posts and threads for X, LinkedIn and Threads	Typefully
Manage many accounts and want one flat price	Fuxux ($29 for 15 accounts) or Post Bridge ($39 for 15)
Run an agency with inbox and reporting needs	Vista Social or Hootsuite

Two more checks before you commit. First, count your posts, not just your accounts: a free plan with 5 or 10 posts a month disappears fast when one post goes to four networks. Second, check that the assistant can publish, not only draft, if you want it to run on its own. Some tools stop at drafts on purpose, which is safer but means you finish the job in their app.

How to connect one in five minutes

Create an account with the scheduler and connect your social accounts there first. The assistant can only post where the scheduler can.
In Claude, open Settings, then Connectors, and browse the directory. In ChatGPT, open Plugins and search. Add the tool, sign in and approve access.
If the tool is not listed, add it as a custom connector with the server URL from its docs. In ChatGPT this needs a paid plan.
Start with a safe request: "List my connected accounts", then "Draft a LinkedIn post about X and save it as a draft". Check the draft in the scheduler before you let the assistant publish.

For Fuxux, the step-by-step guides are on Fuxux for Claude and Fuxux for ChatGPT, and the technical details are in the MCP docs. For background on how this works, see how to schedule social media posts with MCP.

FAQ

Can ChatGPT post to Instagram or TikTok by itself?

Not by itself. ChatGPT needs a scheduler connected as a plugin or connector, and that scheduler holds the permission to post to your accounts. Instagram and TikTok also need the right account type: an Instagram professional account, and for TikTok, a scheduler approved for direct posting.

Do I need an API key?

Not for Claude or ChatGPT with the tools in the directories: you sign in and approve. API keys are for developer tools such as Cursor or Claude Code with a header, and for scripts.

Is it safe to let an AI assistant post for me?

Start with drafts and review them. The assistant only gets the tools the scheduler exposes, and you can remove the connection at any time from the assistant's settings or the scheduler. Treat "publish now" like giving a colleague the keys: fine once you trust the workflow.

Which tool has the most free posts?

Among the free options with a sign-in connection, Buffer: 3 channels with 10 scheduled posts each. Metricool allows 20 a month but leaves out LinkedIn and X.

Which ones post to Telegram or Slack?

From this list, Fuxux and Postiz post to both, and Publer posts to Telegram. Fuxux is the only one of them with a free plan.

The bottom line

The AI part has become table stakes: most good schedulers now give Claude and ChatGPT the same basic tools. Choose on the plain things: whether you can connect with a sign-in on the plan you will actually pay for, the networks you need, and how the price grows with your accounts. If you want to try the workflow today without a card, Fuxux's free plan connects to both assistants in a couple of minutes.

Originally published on the Fuxux blog.

Stripe told us a plan changed. It hadn't.

Alex — Mon, 19 Oct 2026 09:44:55 +0000

We run a small social media scheduler, and the events we care about send us a message in Telegram: a new sign-up, a new subscription, a plan change, a billing error. It's a cheap way to know what's happening without opening a dashboard.

Last Friday afternoon one of those messages said:

Plan changed: Creator, monthly

Nobody had changed anything. The subscription was on the same plan, at the same price, as the day before. What had actually happened was much more boring: a 7-day trial had ended and the first paid month had started.

The alert was wrong, and the reason is a detail of Stripe webhooks that is easy to miss.

What the alert code did

Plan changes come in as customer.subscription.updated. That event fires for a lot of reasons (status changes, renewals, metadata edits), so we only wanted to alert when the plan itself changed. Stripe sends previous_attributes with every update: the fields that changed, with their old values. So the check looked like this:

const previousAttributes = (
  event.data as { previous_attributes?: Partial<Stripe.Subscription> }
).previous_attributes;

// "items changed" = "the customer switched plans"
if (previousAttributes?.items) {
  notifyOpsSubscription({ kind: "plan_change", /* ... */ });
}

The reasoning: the plan lives on the subscription item's price, so if items is in previous_attributes, the plan must have changed.

What Stripe actually sent

When the trial ended, the update looked roughly like this (trimmed):

{
  "type": "customer.subscription.updated",
  "data": {
    "object": {
      "status": "active",
      "items": { "data": [{ "price": { "id": "price_creator_monthly" } }] }
    },
    "previous_attributes": {
      "status": "trialing",
      "items": { "data": [{ "price": { "id": "price_creator_monthly" } }] }
    }
  }
}

items is there, but the price inside it is the same. In recent Stripe API versions the billing period (current_period_start and current_period_end) lives on the subscription item, not on the subscription. When a trial ends, the period moves from the trial week to the first paid month. The item changed, so items shows up in previous_attributes, even though nobody touched the plan.

previous_attributes tells you which top-level field changed. It doesn't tell you what changed inside it.

The fix

Compare the value you care about instead of checking that the field exists:

const previousPriceId = previousAttributes?.items?.data?.[0]?.price?.id;

// Alert only when the price itself changed (an upgrade or downgrade).
if (previousPriceId && previousPriceId !== priceId) {
  notifyOpsSubscription({ kind: "plan_change", /* ... */ });
}

Now a trial ending, a renewal or a period change is just an update. A real switch from one price to another still alerts. Billing itself was never affected: the plan we store comes from the current price on every update, so only the notification was wrong.

What I'd check in your own webhook

Search for previous_attributes?.something used as a boolean. Each one is "this field changed somehow", which is rarely the question you're asking.
Diff the exact value you care about: the price ID for plan changes, status for activations, cancel_at_period_end for cancellations.
Test the trial end, not just the checkout. Most of us test "subscribe" and "cancel" by hand and never sit through a trial. Stripe's test clocks let you move a test subscription past its trial end in a few seconds.
Expect nested objects to change for reasons that aren't yours. Stripe moves fields between versions, and anything nested (items, discounts, invoice settings) can appear in previous_attributes after an API upgrade.

The alert that caught this was a false alarm, but it did its job: it made us look. If it had been an email to the customer saying "your plan changed", it would have been a support ticket instead.

We build Fuxux, a social media scheduler for creators. This bug came out of our own billing alerts last week.

string.length is wrong for X and Bluesky. My counter failed 8 of 34 tests against X's own library

Alex — Mon, 12 Oct 2026 16:55:59 +0000

I'm Alex. I build Fuxux, a social media scheduler: you write a post once and it goes out to X, Bluesky, Instagram, LinkedIn, Threads and a few more.

A scheduler has to answer one boring question before anything is sent: does this text fit? I assumed that was text.length <= limit. It isn't, and the two networks with the smallest limits are the two where it goes wrong.

I also thought I had already solved it. Then I sat down to write this post, checked my own code against X's library to get the examples right, and it was wrong on 8 of 34 strings. So this is the corrected version, with the mistake left in.

Three ways to count one string

Take ok 👍🏽. That's "ok", a space, and a thumbs up with a skin tone.

const text = "ok 👍🏽";

text.length;        // 7  UTF-16 code units
[...text].length;   // 5  code points
[...new Intl.Segmenter(undefined, { granularity: "grapheme" })
  .segment(text)].length; // 4  what a person sees

Three honest answers. Which one a network uses decides whether your post is accepted.

String	`length`	X counts	Bluesky counts
`ok 👍🏽`	7	5	4
`👨‍👩‍👧‍👦` (family)	11	2	1
`🇪🇸` (flag)	4	2	1
`こんにちは`	5	10	5
`𝗯𝗼𝗹𝗱` (bold "font")	8	8	4
`read fuxux.com now`	18	32	18
a 140-character URL	140	23	140

The X column is from X's own library. The Bluesky column is the grapheme count.

X: weights, not characters

X publishes how it counts in an open source library, twitter-text. The limit is 280, but 280 of a weighted unit:

Latin letters, digits and common punctuation weigh 1. In code point terms: U+0000 to U+10FF, U+2000 to U+200D, U+2010 to U+201F and U+2032 to U+2037.
Everything else weighs 2. That's why five Japanese characters cost 10, and why those bold "fonts" people paste into bios cost double: they are mathematical letters far outside the Latin range.
An emoji weighs 2, as a whole. A family of four is seven code points glued with joiners and it is still 2.
Any link weighs 23, whether it is 9 characters or 140.
The text is normalised to NFC first, so e plus a combining accent counts as one é.

The link rule bites in two directions. A long URL is cheaper than it looks. A short one is more expensive: fuxux.com is 9 characters and costs 23.

And it catches text you didn't mean as a link. It works.So does this is 21 characters. X counts 36, because a missing space after the full stop makes works.So look like a domain (.so is a real ending).

Where I got it wrong

My first version walked the string one code point at a time and added 1 or 2:

function weigh(text) {
  let total = 0;
  for (const char of text) total += xWeight(char.codePointAt(0));
  return total;
}

That handles a plain 👍 (one code point, weight 2). It falls apart on anything built from several:

String	X	My first version
`ok 👍🏽`	5	7
`👨‍👩‍👧‍👦`	2	11
`🇪🇸`	2	4
`1️⃣`	2	5
`❤️`	2	4

It always over-counted, so nobody could post something too long because of it. It just told people their post didn't fit when it did. On a 280 limit, a few emoji with skin tones is enough to matter.

The fix is to split into graphemes first, and count a grapheme that is an emoji as 2 no matter what it is made of:

const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });

// Drawn as an emoji by default, or a symbol followed by the emoji
// selector, or a flag letter, or a keycap like 1️⃣.
const EMOJI =
  /\p{Emoji_Presentation}|\p{Extended_Pictographic}️|\p{Regional_Indicator}|[0-9#*]️?⃣/u;

function xWeight(cp) {
  return (cp <= 0x10ff) ||
    (cp >= 0x2000 && cp <= 0x200d) ||
    (cp >= 0x2010 && cp <= 0x201f) ||
    (cp >= 0x2032 && cp <= 0x2037) ? 1 : 2;
}

function weigh(text) {
  let total = 0;
  for (const { segment } of segmenter.segment(text)) {
    if (EMOJI.test(segment)) { total += 2; continue; }
    for (const char of segment) total += xWeight(char.codePointAt(0));
  }
  return total;
}

function countForX(text, urlPattern) {
  const s = text.normalize("NFC");
  let total = 0, last = 0;
  for (const m of s.matchAll(urlPattern)) {
    total += weigh(s.slice(last, m.index)) + 23;
    last = m.index + m[0].length;
  }
  return total + weigh(s.slice(last));
}

My second attempt was also wrong, in a smaller way. I used \p{Extended_Pictographic} on its own, and © 2026 came out as 7 instead of 6. A bare © is in that Unicode class, but X only treats it as an emoji when the emoji selector (U+FE0F) follows it. Same for a text heart ❤ versus ❤️. Hence the longer pattern above.

It now matches twitter-text on 43 of my 44 test strings. The one it misses is a link ending I don't carry: X knows every domain ending there is, and I keep a short list of the common ones, so a.community is a link to X and plain text to me. If you need that last case, use their list.

Which is the real advice here: if you can ship the dependency, call twitter.parseTweet(text).weightedLength and be done. I wanted something small that runs in the browser as you type, so I wrote my own and test it against theirs.

Bluesky: graphemes, and a second limit behind it

Bluesky's limit is 300, and it counts graphemes. The post schema says so directly: maxGraphemes: 300. So the family emoji is 1, the flag is 1, and ok 👍🏽 is 4. Intl.Segmenter gives you that number in every current browser and in Node.

The same schema also has maxLength: 3000, and that one is in UTF-8 bytes. Normal text never gets near it. Three hundred family emoji would, at 25 bytes each.

The rest

For Instagram, LinkedIn, Threads, Facebook and the others I count text.length. I have not checked each of them emoji by emoji the way I just did for X, so I won't claim more than that. Their limits are large enough (500 on Threads, 2,200 on Instagram, 3,000 on LinkedIn) that a few units either way rarely decides anything. On 280 and 300 it does.

If you only need the numbers, I keep the limits for all 12 networks in one table.

Try it

The counter is free and needs no account: fuxux.com/tools/character-counter. Paste a post and it shows the count for each network side by side, using the rules above. Paste ok 👍🏽 and you'll see X and Bluesky disagree.

The limits in it are the same numbers Fuxux uses when it publishes. If you'd rather not think about any of this, that's what the scheduler is for, and there's a free plan (3 social accounts, 5 posts a month, no card).

If you know a string where X's count surprised you, put it in the comments. I'll add it to the tests.

What it took to get an MCP server into Claude's directory (and what broke along the way)

Alex — Sat, 10 Oct 2026 14:39:00 +0000

I'm Alex. I build Fuxux on my own. It's a social media scheduler: you write a post once and it goes out to Instagram, TikTok, YouTube, LinkedIn, X, Threads, Bluesky, Pinterest and a few more, each with its own caption.

I wanted one thing: to open Claude, type "schedule this for LinkedIn tomorrow at 9", and have it actually happen. Fuxux already had an MCP server, but it worked with an API key you paste into your client. Fine for Cursor. Useless for Claude's directory and for ChatGPT, because there is nowhere to paste a key. They want your server to handle sign-in.

Most of the work turned out to be small things nobody tells you. So here they are, in the order I hit them.

1. My server was failing the wrong way

When a request came in without credentials, I returned a 200 with an error message inside. Felt reasonable. It isn't. A client that supports sign-in only starts the flow when it gets a real 401 plus a header telling it where to look:

HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer resource_metadata="https://www.fuxux.com/.well-known/oauth-protected-resource", scope="mcp"

Without that header the client just says the connection failed and gives you nothing else to go on.

2. Two small JSON files that have to be exactly right

/.well-known/oauth-protected-resource says "this is the resource, and this server protects it". The resource value must be the exact URL people connect to. Mine is https://www.fuxux.com/api/mcp. A missing www or an extra slash at the end is enough to break it, and nothing tells you why.
/.well-known/oauth-authorization-server lists your authorize, token and registration endpoints, says you support PKCE with S256, and that public clients are fine (token_endpoint_auth_methods_supported: ["none"]).

3. Claude and ChatGPT don't register the way I expected

I expected every client to register itself with dynamic client registration, because that's what the older examples show. Then I connected Claude and it never called it.

Claude sends a client id that is a URL. You fetch that URL and it gives you a small document with the client's name and where to send the user back. ChatGPT does the same thing with its own document. So you need to support both ways:

Client ID Metadata Documents, for Claude and ChatGPT. Put client_id_metadata_document_supported: true in your metadata.
Dynamic registration, for the tools that still use it. Don't skip it: when I submitted to another catalog recently, I saw a company pull their own submission because their server didn't have it.

ChatGPT had one more surprise for me. Its document says token_endpoint_auth_method: "private_key_jwt" and lists ["none", "private_key_jwt"] as supported. My code only accepted none as the method, so ChatGPT users got my "this sign-in request is not valid" page. The fix was to accept any client that lists none as supported, and treat it as a public client with PKCE.

And their review scan checks your tools. Every tool has to say readOnlyHint, destructiveHint and openWorldHint out loud. It flagged my "update post" tool because I had marked it as not destructive. Fair. Editing a post can overwrite a caption you can't get back.

4. Not every app comes back to an https address

Claude Code and other terminal tools listen on http://localhost and pick a new port each time. If you compare the return address as an exact string, a sign-in works once and fails the next time. For localhost you have to ignore the port (it's in RFC 8252).

Some apps come back to their own scheme, like something://callback. I don't accept those yet, only https and localhost. So those apps still use an API key with Fuxux for now. I wrote that on the setup page instead of pretending.

5. Turning sign-in on took one of my listings down

This one I didn't see coming. A directory that checks my server every hour suddenly marked it as unhealthy. Nothing was broken. Their check calls the server with no credentials, which used to get a 200 and now got a 401. I had to go into their dashboard and authorise a test account. I only knew because they emailed me.

If you're listed anywhere, check your listings the day you switch.

6. The consent screen has to be true

When someone connects Claude to Fuxux, the screen tells them what Claude will be able to do. I made sure the code enforces it, not just the text:

a connected assistant gets 8 tools: your posts (list, read, create, edit, delete), your connected accounts, your dashboard, and "who am I"
it can't touch your plan, billing, password or connected accounts
you can remove it in Settings and it stops working right then

I also cut down what the tools send back. "Who am I" returns your email, name and plan. Nothing else leaves.

7. The part that had nothing to do with OAuth

The listing went live and I had my best day ever: 12 sign-ups, 10 of them from Claude. That's more than I usually get in a week.

Two days later I looked at what those people had done. One of the 12 had connected a social account. One.

It took me a while to see why. You find Fuxux in Claude's directory, click connect, sign in on my consent screen, approve, and you're sent straight back to Claude. You now have a Fuxux account and you have never seen Fuxux. No onboarding. Nobody asked you to connect Instagram. So you ask Claude to schedule a post and there's nothing to post to.

What I changed:

if a tool is called and you have no accounts connected, the answer now tells you what to do next instead of giving back an empty list
one email, sent once, after you approve the connector with nothing connected

What's still on my list is a "connect your first account" step right after you approve.

So if you're building for one of these directories: test it as someone who has never been on your site. That's who shows up.

What you can do with it now

Once it's connected, this is the kind of thing you can ask:

"What do I have scheduled this week, and did anything fail?"
"Write a post about our new pricing page, one version for LinkedIn and one for Bluesky, and save both as drafts"
"Move tomorrow's Instagram post to Friday at 9"

It works from Claude (it's in Claude's directory), Claude Code, ChatGPT and Cursor, and there's a setup page for Codex too. Each one takes about a minute:

There's a free plan: 3 social accounts and 5 posts a month, no card. Enough to try the whole thing from your assistant and see if it fits how you work.

If you're building your own MCP server and get stuck on any of the steps above, ask in the comments. I've probably hit it.