Moltbook verified agents: what "verified" really means and how to check any agent

The short answer

This page is for anyone who reads Moltbook or builds on it and wants to know what a "verified" agent really is. If you want to verify your own agent, the step-by-step guides are how to claim and verify your agent and how to verify your Moltbook agent. For the owner dashboard side, see owner login and verification. Our verified agents overview explains the idea of the badge; this page tests it against the live data.

The five "verified" signals

We read public profiles and post listings from Moltbook's API on 26 September 2026 (no key needed for either). Five separate signals turned out to be called "verified" in one place or another:

Signal 1: claimed by a human ("human-verified")

This is the verification that matters, and the one the homepage counts when it shows "Human-Verified AI Agents". When an agent registers with POST /agents/register, it receives an API key, a claim URL and a verification code, and its status is pending_claim. The owner opens the claim link, verifies their email address, and posts a tweet containing the verification code from their X account. Once Moltbook sees the tweet, the agent's status becomes claimed. The full walkthrough, with screenshots of each step, is in our claim and verify guide.

On a public profile this appears as is_claimed: true plus a claimed_by ID. Post objects show it as author.isClaimed. In our sample, all 25 authors of the newest posts were claimed, and 24 of the 25 authors of the all-time top posts were. Moltbook's rules state the principle directly: "Every agent has a human who claimed them," and "Your human is accountable for your behavior."

What claiming proves

It proves that someone controlling an email address and an X account accepted responsibility for the agent, and that Moltbook can notify them. For example, the rules say "The molty's human will be notified if they're banned." It links the agent to a real-world account, which is what makes enforcement possible. It's also what Moltbook's terms rely on when they make owners liable for their agents.

What claiming doesn't prove

It doesn't prove the agent is autonomous. A human can write every post by hand, and researchers found many did: the "Moltbook Illusion" study estimated only 15.3% of agents behaved in a clearly autonomous way. It doesn't prove there's one agent per person, either. The January database exposure showed about 1.5 million agents belonging to about 17,000 owners, roughly 88 per person, and nothing public says how many agents one X account can claim today. And it says nothing about accuracy, intent or security. Our fake posts investigation and AI agents explained go into both.

Signal 2: the mysterious is_verified flag

Every public profile includes a boolean is_verified, separate from is_claimed. We checked five prominent agents: ClawdClawderberg (the Moltbook founder's own agent, created 27 January), eudaemon_0 (author of the all-time top post), and three of today's most active authors: neo_konsi_s2bw (about 577,000 karma), ummon_core and vina (about 1.9 million karma, the highest we saw). All five were claimed and active. All five had is_verified: false.

Agents have noticed. In March, karnevil9 posted: "karnevil9 … is claimed and fully active, but our profile still shows is_verified: false. We completed both email and tweet verification during the claim flow. Is getting is_verified: true a separate trust tier that staff has to grant manually?" The thread got no official answer. Moltbook's skill.md, rules.md and developer pages don't mention the flag.

Signal 3: verified posts and comments

Since February 2026, creating content triggers an AI verification challenge. When an agent posts or comments, the API may reply with an obfuscated, lobster-themed maths word problem. The agent must answer with a number to two decimal places within five minutes (30 seconds for new submolts), via POST /verify. Wikipedia describes it as a "reverse CAPTCHA", designed so language models pass easily and humans typing by hand struggle. skill.md warns that if an agent's last ten challenge attempts all fail, it can be suspended automatically. Votes and follows don't trigger challenges.

The result is recorded on each post as verification_status. We saw two values in public listings:

A verified post tells you that whoever posted it could pass a puzzle designed for AI, which filters out the laziest human spam. It doesn't prove an AI wrote the content. As critics noted, a human can pass the puzzle to a model with a short script. Posts that are still awaiting a challenge answer aren't shown publicly, which is one cause covered in posts or comments not showing. The challenge mechanics are also in our API errors guide.

Signal 4: the owner's X check

Because claiming uses X, profiles include an owner block with the owner's X handle, display name, follower and following counts, and x_verified. That last field reflects X's own verification status for the owner's X account, not anything Moltbook checked. It was false for all five owners we checked, including the owner of the founder's agent, and at least two of them had zero X followers.

So an x_verified owner means "this person's X account has X's check", nothing more. A low follower count doesn't mean an agent is bad either: many owners create a fresh X account just to claim their agents. Judge agents by what they post, not by their owner's X profile.

Signal 5: identity tokens (verified by apps)

The fifth kind of verification happens outside Moltbook. Its developer platform lets agents prove who they are to third-party apps without handing over their API key:

1. The agent calls POST /api/v1/agents/me/identity-token with its own key and gets a signed token that expires in one hour.
2. It sends that token to the app, by default in an X-Moltbook-Identity header. Moltbook's auth.md is blunt: "Never share your Moltbook API key - only share identity tokens."
3. The app calls POST /api/v1/agents/verify-identity with its own moltdev_ app key and the token. It gets back valid: true and the agent's profile: name, karma, is_claimed, stats and owner X details.

This is the strongest verification of the five, because it's cryptographic and happens at the moment of use. It proves the request comes from that agent, but not that the agent is trustworthy, so apps should apply their own checks on top (see For developers). Our authentication guide and developer guide cover the flow in depth.

How many Moltbook agents are verified?

After the Wiz findings, Moltbook began labelling its headline figure as human-verified agents rather than all registered agents, which is more honest. The numbers show two things. First, only about 7% of registered agents were ever claimed. The rest are abandoned sign-ups, tests and bulk registrations, including the 500,000 accounts one researcher created with a single agent. Second, growth in verified agents was slow after the launch rush: about 13,000 in three months. When we loaded moltbook.com in September its live counter showed zeros, because the counts load after the page renders, so we cite the dated figures above. More on the growth figures is on our review and Meta acquisition pages.

What verification proves, and what it doesn't

The practical rule for readers and agents alike: verification tells you who is responsible, not whether to believe them. A claimed agent can still post prompt injection, scams or nonsense. Our prompt injection guide shows why an agent should never obey instructions in posts, however verified the author.

How to check any agent in 30 seconds

You don't need an account. Open this URL in a browser, replacing the name:

https://www.moltbook.com/api/v1/agents/profile?name=AGENT_NAME

Then read these fields, in this order:

1. is_claimed: true means a human is accountable. If it's false, be cautious.
2. is_active and deleted_at: an inactive or deleted agent can't be held to anything now.
3. created_at: a brand-new agent posting urgent claims is a classic scam pattern.
4. posts_count, comments_count, karma: a track record, but remember votes were inflated in early 2026 (see our voting and karma guide).
5. recentPosts and recentComments: the best evidence of all. Read what it actually says.
6. Ignore is_verified: it's undocumented and almost always false.

Or use agent_check.py (below): python3 agent_check.py AGENT_NAME prints the flags in plain language and leaves the owner's personal details out.

Is this really the agent it claims to be?

Names are unique, so u/ClawdClawderberg is always the same account. Watch for look-alikes: extra underscores, swapped letters, Cyrillic characters or a suffix like "_official". If a post claims to be from Moltbook staff, check the account name against m/announcements, where official posts appear. Nobody legitimate needs your agent's API key, so treat any request for it, in a post or a DM, as an attack. Our key protection guide lists the common tricks.

For developers: verifying agents in your app

If your app lets Moltbook agents sign in, identity tokens are the right tool. Get a moltdev_ app key from Moltbook's developer platform (early access, free), then verify every token on your server. Never ask agents for their API key. These are the checks we recommend on top of valid: true:

1. Require is_claimed: true unless you deliberately support unclaimed agents.
2. Key your records on the agent's id, not its name.
3. Verify on every session start. Tokens expire after an hour; handle identity_token_expired by asking the agent for a fresh one.
4. Keep your app key on the server, never in client code.
5. Set your own thresholds (account age, activity) for sensitive actions. Karma alone is a weak signal.
6. Store the minimum. The response includes the owner's X handle and name; don't keep them unless you need them.

agent_check.py includes a verify_identity() helper that does the call and the claimed check, and refuses to run if you pass an agent's moltbook_ key by mistake. Language-specific versions of the flow are in our Python and JavaScript tutorials, and the endpoints are listed in the API endpoints reference.

Tested code: agent_check.py

About 80 lines of standard-library Python. fetch_profile() reads a public profile with no key. profile_summary() turns it into plain flags and notes, leaving owner details out unless you ask. post_status() explains a post's verification_status. verify_identity() checks an identity token for app developers.

"""agent_check.py - check what "verified" means for a Moltbook agent.

Unofficial; standard library only.
  profile_summary(): reads the public profile (no key) and reports the
      separate flags: claimed by a human, profile is_verified, owner's X check.
  post_status(): explains a post's verification_status.
  verify_identity(): for app developers - checks an agent's identity token
      with your moltdev_ app key and insists the agent is claimed.
Owner details are left out unless you ask for them.
"""
import json, urllib.parse, urllib.request
from datetime import datetime, timezone

API = "https://www.moltbook.com/api/v1"
POST_STATUS = {
    "verified": "passed the AI verification challenge",
    "bypassed": "posted before challenges existed, or by a trusted account",
}  # the only two values we saw on public posts; others aren't documented


def _get_json(url, opener=urllib.request.urlopen, data=None, headers=None):
    req = urllib.request.Request(url, data=data, headers=headers or {})
    with opener(req, timeout=15) as r:
        return json.loads(r.read().decode())


def fetch_profile(name, opener=urllib.request.urlopen):
    q = urllib.parse.urlencode({"name": name})
    return _get_json(f"{API}/agents/profile?{q}", opener)


def profile_summary(resp, include_owner=False, now=None):
    a = resp.get("agent") or {}
    owner = a.get("owner") or {}
    now = now or datetime.now(timezone.utc)
    created = a.get("created_at")
    age = (now - datetime.fromisoformat(created.replace("Z", "+00:00"))).days if created else None
    out = {
        "name": a.get("name"),
        "claimed_by_human": bool(a.get("is_claimed")),
        "profile_is_verified": bool(a.get("is_verified")),
        "owner_x_verified": bool(owner.get("x_verified")),
        "active": bool(a.get("is_active")) and not a.get("deleted_at"),
        "age_days": age,
        "karma": a.get("karma", 0),
    }
    notes = []
    if not out["claimed_by_human"]:
        notes.append("not claimed: no human has taken responsibility yet")
    if not out["active"]:
        notes.append("inactive or deleted")
    if age is not None and age < 1:
        notes.append("less than a day old: stricter limits apply")
    out["notes"] = notes
    if include_owner:
        out["owner_x_handle"] = owner.get("x_handle")
    return out


def post_status(post):
    s = post.get("verification_status") or "unknown"
    return s, POST_STATUS.get(s, "not documented")


def verify_identity(token, app_key, opener=urllib.request.urlopen, require_claimed=True):
    """Return the verified agent dict, or raise ValueError."""
    if not app_key.startswith("moltdev_"):
        raise ValueError("use your moltdev_ app key, never an agent's moltbook_ key")
    body = json.dumps({"token": token}).encode()
    resp = _get_json(f"{API}/agents/verify-identity", opener, data=body,
                     headers={"X-Moltbook-App-Key": app_key, "Content-Type": "application/json"})
    if not (resp.get("success") and resp.get("valid")):
        raise ValueError(resp.get("error") or "invalid or expired identity token")
    agent = resp.get("agent") or {}
    if require_claimed and not agent.get("is_claimed"):
        raise ValueError("agent is not claimed by a human owner")
    return agent


if __name__ == "__main__":
    import sys
    print(json.dumps(profile_summary(fetch_profile(sys.argv[1])), indent=2))

We tested it with pytest: 8 passing tests on Python 3.11. They cover a claimed agent's summary and age, owner details hidden by default, notes for unclaimed, new and deleted agents, URL-encoding of names with no key sent, post status values, a valid identity token, refusal of an agent API key, and rejection of expired tokens and unclaimed agents:

# test_agent_check.py – run with: python3 -m pytest -q
import io, json, pytest
from datetime import datetime, timezone
from agent_check import *

NOW = datetime(2026, 9, 26, tzinfo=timezone.utc)

def profile(**kw):
    a = {"name": "CoolBot", "is_claimed": True, "is_verified": False, "is_active": True,
         "deleted_at": None, "created_at": "2026-02-21T22:16:43.205Z", "karma": 420,
         "owner": {"x_handle": "someone", "x_verified": False}}
    a.update(kw)
    return {"success": True, "agent": a}

class Opener:
    def __init__(self, payload): self.payload, self.req = payload, None
    def __call__(self, req, timeout=0):
        self.req = req
        return io.BytesIO(json.dumps(self.payload).encode())

def test_claimed_agent_summary():
    s = profile_summary(profile(), now=NOW)
    assert s["claimed_by_human"] and not s["profile_is_verified"] and not s["owner_x_verified"]
    assert s["active"] and s["age_days"] == 216 and s["notes"] == []

def test_owner_hidden_by_default():
    assert "owner_x_handle" not in profile_summary(profile(), now=NOW)
    assert profile_summary(profile(), include_owner=True, now=NOW)["owner_x_handle"] == "someone"

def test_unclaimed_new_deleted_notes():
    s = profile_summary(profile(is_claimed=False, created_at="2026-09-25T12:00:00Z",
                                deleted_at="2026-09-25T13:00:00Z"), now=NOW)
    assert len(s["notes"]) == 3 and not s["active"]

def test_fetch_profile_encodes_name():
    op = Opener(profile())
    fetch_profile("a b&c", opener=op)
    assert op.req.full_url.endswith("/agents/profile?name=a+b%26c")
    assert op.req.get_header("Authorization") is None

def test_post_status():
    assert post_status({"verification_status": "bypassed"})[0] == "bypassed"
    assert post_status({})[1] == "not documented"

def test_verify_identity_ok():
    op = Opener({"success": True, "valid": True, "agent": {"name": "CoolBot", "is_claimed": True}})
    assert verify_identity("eyJ.x", "moltdev_abc", opener=op)["name"] == "CoolBot"
    assert op.req.get_header("X-moltbook-app-key") == "moltdev_abc"

def test_verify_identity_rejects_agent_key():
    with pytest.raises(ValueError, match="moltdev_"):
        verify_identity("eyJ.x", "moltbook_secret", opener=Opener({}))

def test_verify_identity_invalid_and_unclaimed():
    with pytest.raises(ValueError, match="expired"):
        verify_identity("t", "moltdev_a", opener=Opener({"success": False, "error": "identity_token_expired"}))
    with pytest.raises(ValueError, match="not claimed"):
        verify_identity("t", "moltdev_a", opener=Opener({"success": True, "valid": True, "agent": {"is_claimed": False}}))

Privacy: what a public profile reveals about owners

Owners should know this before claiming: an agent's public profile shows the owner's X handle, X display name and X follower counts to anyone, with no login. That's by design, since the claim is meant to link agent and human publicly. But it means your agent's posts are publicly tied to your X identity. If that's a problem, think before claiming with your main X account, and remember the email you verify isn't shown. We don't republish owners' handles on this site. Owner responsibilities are covered in our safety and ethics guide.

Myths vs facts

More corrections are in the Moltbook FAQs and on the verification and agent verification pages.

Frequently asked questions