The Easiest Integration We've Ever Done: Two Markdown Files and a Domain Name Identity Crisis

After wrestling with Zapier OAuth and navigating Pipedream's human-first process, we braced ourselves for ClawHub.

"What hoops will we have to jump through this time?"

The answer: None. Zero hoops. Two markdown files. Done.

The Domain Name Identity Crisis

Before we get into the integration, let's address the elephant in the room.

This platform has had more domain names than I've had hot dinners:

calwd.com → openclaw.ai → clawhub.ai

I'm genuinely not sure what to call it in conversation anymore.

"Hey, have you seen that AI skills platform?"
"Which one?"
"You know... the claw one?"
"Calwd?"
"No, they changed it."
"OpenClaw?"
"Nope, changed again."
"ClawHub?"
"...for now."

At this point, I half expect to wake up tomorrow and find it's now crabpeople.io.

But here's the thing: the product is actually really good. The domain name musical chairs? Just a startup finding its footing. It happens.

The Integration: Two Files

I'm not exaggerating. The entire Jo4 integration is:

smoothtalk/clawhub/
├── README.md     (33 lines)
└── SKILL.md      (190 lines)

That's it. No OAuth dance. No webhook infrastructure. No SDK to build. Just... markdown.

The README.md

A quick intro for humans:

# Jo4 - URL Shortener & Analytics

🔗 **[jo4.io](https://jo4.io)** - Modern URL shortening with QR codes and detailed analytics.

## Features

- **Short URLs** - Custom aliases, branded links
- **QR Codes** - Auto-generated for every link
- **Analytics** - Clicks, geography, devices, referrers
...

The SKILL.md

This is where the magic happens. It's a markdown file with YAML frontmatter that tells the AI how to use your API:

---
name: jo4
description: URL shortener, QR code generator, and link analytics API
homepage: https://jo4.io
user-invocable: true
metadata:
  openclaw:
    emoji: "🔗"
    primaryEnv: "JO4_API_KEY"
    requires:
      env: ["JO4_API_KEY"]
---

Then you just... document your API. In markdown. With curl examples.

### Create Short URL (Authenticated)

\`\`\`bash
curl -X POST "https://jo4-api.jo4.io/api/v1/protected/url" \
  -H "X-Jo4-API-Key: $JO4_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"longUrl": "https://example.com", "title": "My Link"}'
\`\`\`

The AI reads this, understands the API structure, and can now use it. No code generation. No SDK maintenance. Just documentation that doubles as integration.

Why This Works

ClawHub's approach is beautifully simple:

1. Documentation IS the integration - If you can document it, it's integrated
2. Curl examples are universal - Any AI can understand curl -X POST
3. Environment variables for auth - JO4_API_KEY in the metadata, done
4. No deployment - Push to their repo, it's live

Compare this to:

• Zapier: OAuth implementation, webhook infrastructure, app review, QA queue
• Pipedream: GitHub issue, email credentials, component code, QA queue
• ClawHub: Write markdown. Push. Done.

The Live Integration

It's already live at clawhub.ai/anandrathnas/jo4.

Users can now ask their AI:

"Shorten this URL: https://example.com/really-long-path"

And it just... works. The AI reads the SKILL.md, finds the right endpoint, makes the call.

What We Documented

All in markdown. All with curl examples. Total effort: maybe 30 minutes.

The Metadata That Makes It Work

The frontmatter is the secret sauce:

metadata:
  openclaw:
    emoji: "🔗"
    primaryEnv: "JO4_API_KEY"
    requires:
      env: ["JO4_API_KEY"]

This tells ClawHub:

• Show the 🔗 emoji in the UI
• The main credential is JO4_API_KEY
• Don't let users invoke without that env var set

No complex OAuth scopes. No token refresh logic. Just "need this env var? yes/no."

Lessons Learned

1. Sometimes Simpler Is Better

After OAuth flows and webhook subscriptions, a markdown file feels almost too easy. But it works. Users get value. That's what matters.

2. Documentation-as-Integration Is Genius

If your docs are good enough for an AI to understand, they're probably good enough for humans too. This forces you to write clear, example-driven documentation.

3. Domain Names Are Just Names

Calwd. OpenClaw. ClawHub. Who cares? The product works. The integration was painless. I'll update my bookmarks as needed.

Integration Complexity Comparison

The Future-Proofing Question

"What if they change the domain again?"

Honestly? I'll update the bookmark. The integration itself won't break—it's just markdown files in a repo.

"What if they rename the whole product?"

Then I'll have another blog post to write. Content calendar wins either way.

Try It Yourself

If you have a REST API with decent documentation, you can probably integrate with ClawHub in an afternoon:

1. Create a SKILL.md with frontmatter
2. Document your endpoints with curl examples
3. Specify required env vars in metadata
4. Push to their repo
5. Done

No OAuth implementation. No webhook infrastructure. No SDK maintenance.

Sometimes the best integrations are the ones that don't feel like integrations at all.

What's the easiest integration you've ever done? And have you noticed any other products with domain name identity issues?

Building jo4.io - URL shortener with analytics. Now available on ClawHub... whatever they call it next week.