Integrations

Wire Notipo into whatever you already use.

Notipo exposes the same WordPress pipeline through three transports — an MCP server, a REST API, and a CLI. Grab the copy-paste config for your tool below and you have a publisher. No WordPress plugin, no in-app editor.

Every setup starts the same way: sign up at app.notipo.com, copy your API key from Settings → Account, and (for CLI/REST tools) export it as NOTIPO_API_KEY. Then drop in the snippet for your tool.

AI agents & MCP clients

One endpoint, 13 tools. Four speak MCP; four call the REST API.

Claude Desktop

MCP

Anthropic's desktop chat app. Paste this under mcpServers in claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/), restart, and Claude gets 13 tools to draft, format, and publish.

claude_desktop_config.json
json
{  "mcpServers": {    "notipo": {      "type": "streamable-http",      "url": "https://app.notipo.com/api/mcp",      "headers": {        "x-api-key": "your-api-key"      }    }  }}

Claude Code

MCP

Anthropic's CLI agent. One claude mcp add command and Claude publishes from any terminal session — turn shell-history learnings or a build script into a live post.

terminal
shell
# One-time installclaude mcp add --transport http notipo \  https://app.notipo.com/api/mcp \  --header "x-api-key: $NOTIPO_API_KEY"# Verifyclaude mcp list# Use it from any session# > Claude, draft and publish a post about Cloud Run cold starts.

Cursor

MCP

AI-native code editor. The same MCP block drops into Cursor Settings → MCP (or .cursor/mcp.json in your project root) — your editor's agent becomes a publisher.

.cursor/mcp.json
json
{  "mcpServers": {    "notipo": {      "type": "streamable-http",      "url": "https://app.notipo.com/api/mcp",      "headers": {        "x-api-key": "your-api-key"      }    }  }}

Goose

MCP

Block's open-source on-machine agent, running on any LLM (Anthropic, OpenAI, OpenRouter, local). Run goose configure → Add Extension → Remote Extension (HTTP), or edit config.yaml directly.

~/.config/goose/config.yaml
yaml
# Goose extension config — Notipo MCP server# Add via Goose CLI:goose configure# Choose: Add Extension → Remote Extension (HTTP)# Endpoint:    https://app.notipo.com/api/mcp# Header:      x-api-key: $NOTIPO_API_KEY# Or edit ~/.config/goose/config.yaml directly:extensions:  notipo:    type: streamable_http    url: https://app.notipo.com/api/mcp    headers:      x-api-key: ${NOTIPO_API_KEY}    enabled: true# Now Goose can use 13 Notipo tools in any session:#   list_posts, get_post, create_post, direct_publish,#   update_post, publish_post, delete_post,#   list_categories, list_tags, get_job, list_jobs,#   get_settings, sync_now

ChatGPT

Custom GPT Action

ChatGPT doesn't speak MCP yet — call Notipo's REST API from a Custom GPT. Under Configure → Actions, paste this OpenAPI 3.1 schema and set API Key auth with your key in the x-api-key header.

notipo-action.yaml
yaml
# Add as an Action in your Custom GPT# OpenAPI 3.1 — paste this under Actions → Schemaopenapi: 3.1.0info:  title: Notipo  version: 1.0.0servers:  - url: https://app.notipo.com/apipaths:  /posts/direct:    post:      operationId: createAndPublish      summary: Create and publish a WordPress post      requestBody:        required: true        content:          application/json:            schema:              type: object              required: [title, body]              properties:                title: { type: string }                body: { type: string }                category: { type: string }                seoKeyword: { type: string }                publish: { type: boolean }      responses:        '201':          description: Post createdcomponents:  securitySchemes:    apiKey:      type: apiKey      in: header      name: x-api-keysecurity:  - apiKey: []

OpenClaw

REST API

Open-source agent framework — skills, cron, browser, Telegram, memory. It already does the orchestration; one HTTP POST from a skill or cron task publishes the post. Notipo returns 201 with { id, wpPostId, url }.

openclaw skill
shell
# OpenClaw skill — publish a WordPress post via Notipo# In your skill (or cron task), make a single HTTP request:curl -X POST https://app.notipo.com/api/posts/direct \  -H "X-API-Key: $NOTIPO_API_KEY" \  -H "Content-Type: application/json" \  -d '{    "title":      "Why I migrated from n8n to a real app",    "body":       "## Intro\n\nWriting forces clarity...",    "category":   "Engineering",    "seoKeyword": "n8n to app migration",    "publish":    true  }'# OpenClaw can call this from:#   - A skill that runs on demand#   - A cron job ("blog-post" cron, "ship-changelog" cron)#   - A task triggered by Telegram / browser / messaging input## Notipo returns 201 with { id, wpPostId, url } —# pipe it back to Telegram for confirmation, log to memory-store,# whatever your operator setup needs.

Hermes

REST API

Self-improving cloud agent — strong at research, summarization, and long-running tasks. Add a step that POSTs to /api/posts/direct so a routine that finishes can ship its findings without another agent in the loop.

hermes task
shell
# Hermes — publish a WordPress post via Notipo# In a Hermes task or self-improving routine, send one HTTP request:POST https://app.notipo.com/api/posts/directHeaders:  X-API-Key: $NOTIPO_API_KEY  Content-Type: application/jsonBody:{  "title":      "{{ task.title }}",  "body":       "{{ task.body }}",  "category":   "{{ task.category }}",  "seoKeyword": "{{ task.seo_keyword }}",  "publish":    true}# Hermes can publish from:#   - A research task that summarized findings into a post#   - A self-improvement loop documenting what it learned#   - A scheduled task that batches drafts and publishes weekly## Notipo returns 201 with { id, wpPostId, url }.# Hermes can then store the live URL in its working memory.

Replit Agent

REST API

Replit Agent builds inside a repl, then ships the result. Add your key as a Replit Secret named NOTIPO_API_KEY and drop in this ~20-line publish() — the agent reads and calls it like any other file.

publish.ts
typescript
# Replit Agent — publish.ts (TypeScript example)const NOTIPO_API_KEY = process.env.NOTIPO_API_KEY!;async function publish(title: string, body: string, category?: string) {  const res = await fetch("https://app.notipo.com/api/posts/direct", {    method: "POST",    headers: {      "X-API-Key": NOTIPO_API_KEY,      "Content-Type": "application/json",    },    body: JSON.stringify({      title,      body,      category: category ?? "Engineering",      publish: true,    }),  });  if (!res.ok) throw new Error(`Notipo failed: ${res.status}`);  return res.json() as Promise<{ data: { id: string; url: string } }>;}// Use it from anywhere in your Replit project:const result = await publish(  "What I built in Replit today",  await fetch("./notes.md").then((r) => r.text()),);console.log("Live at:", result.data.url);

Automation platforms

One node, module, or step — the whole pipeline behind it.

n8n

HTTP Request node

Notipo started life as a 50-node n8n workflow. Now your workflow needs exactly one HTTP Request node — publish end-to-end from any trigger (RSS, schedule, webhook, AI-agent output).

n8n http request node
shell
# n8n HTTP Request node configurationURL:           https://app.notipo.com/api/posts/directMethod:        POSTAuthentication: Header Auth  Name:        x-api-key  Value:       {{ $env.NOTIPO_API_KEY }}Body:          JSON{  "title":      "{{ $json.title }}",  "body":       "{{ $json.body }}",  "category":   "{{ $json.category }}",  "seoKeyword": "{{ $json.seoKeyword }}",  "publish":    true}# That's it. Notipo handles the rest:#   markdown → Gutenberg, image upload, featured image,#   SEO metadata via Rank Math, publish.

Make.com

HTTP module

One HTTP > Make a request module per scenario. Pull fields from whatever earlier module produces them (Airtable, AI prompt, Google Sheet, RSS); Make handles the trigger, Notipo runs the pipeline.

make.com http module
shell
# Make.com HTTP > Make a request moduleURL:        https://app.notipo.com/api/posts/directMethod:     POSTHeaders:  - Name:   x-api-key    Value:  <your Notipo API key>  - Name:   Content-Type    Value:  application/jsonBody type:  RawContent type: JSON (application/json)Request content:{  "title":      "{{1.title}}",  "body":       "{{1.body}}",  "category":   "{{1.category}}",  "seoKeyword": "{{1.seoKeyword}}",  "publish":    true}# Notipo returns 201 with the live WordPress URL.# Wire that response to a Make.com Slack / email / Sheets module# to get notified or log every publish.

Zapier

Webhooks by Zapier

Replace a 5-step Zap (Notion → Format Markdown → WP Create → WP Upload Media → WP Set SEO) with a single Webhooks by Zapier → POST action. 7000+ Zapier triggers, one publishing endpoint.

zapier webhooks action
shell
# Zapier — "Webhooks by Zapier" → POST actionURL:           https://app.notipo.com/api/posts/directPayload Type:  JSONMethod:        POSTData fields:  title        {{ Trigger field that produces the title }}  body         {{ Trigger field that produces the markdown body }}  category     {{ Optional: Trigger field for category }}  seoKeyword   {{ Optional: Trigger field for focus keyword }}  publish      true        (or false to create a draft)Headers:  X-API-Key        {{ Your Notipo API key (Zapier secret) }}  Content-Type     application/json# Notipo returns 201 with { id, wpPostId, url }.# Pipe the URL to a Slack message, Email, or Sheet via the next Zap step.

GitHub Actions

curl step

Turn any release, push, schedule, or PR-merge into a published post with one curl step. Add NOTIPO_API_KEY as a repository secret; the workflow below ships release notes on every tag.

.github/workflows/publish-release-notes.yml
yaml
# .github/workflows/publish-release-notes.ymlname: Publish release noteson:  release:    types: [published]jobs:  publish:    runs-on: ubuntu-latest    steps:      - name: Send release notes to Notipo        env:          NOTIPO_API_KEY: ${{ secrets.NOTIPO_API_KEY }}          TITLE: "Release ${{ github.event.release.tag_name }}"          BODY: ${{ github.event.release.body }}        run: |          curl -fsSL -X POST https://app.notipo.com/api/posts/direct \            -H "X-API-Key: $NOTIPO_API_KEY" \            -H "Content-Type: application/json" \            -d "$(jq -n \              --arg title "$TITLE" \              --arg body "$BODY" \              '{title:$title, body:$body, category:"Releases", publish:true}')"# That's the whole workflow. Notipo turns the GitHub release notes# (markdown) into a Gutenberg post, hosts images, sets SEO, and publishes.

CLI & REST

Plain HTTP. Works everywhere.

No agent, no platform — just call Notipo directly. The npx notipo CLI and the POST /api/posts/direct endpoint run the same markdown → Gutenberg pipeline. Anything that speaks HTTP — a backend script, a Discord bot, a cron job — can publish. See the CLI reference and the API reference.

terminal
shell
# CLI — publish from any shell or CI jobnpx notipo posts create --title '...' --publish# REST — same pipeline, any HTTP clientcurl -X POST https://app.notipo.com/api/posts/direct \  -H "X-API-Key: $NOTIPO_API_KEY" \  -H "Content-Type: application/json" \  -d '{    "title":      "Hello from a script",    "body":       "# Markdown in, Gutenberg out",    "category":   "Engineering",    "seoKeyword": "wordpress automation",    "publish":    true  }'# Notipo returns 201 with { id, wpPostId, url }.

Tool not listed?

Notipo is a plain REST API, an MCP server, and a CLI. Anything that can speak HTTP can publish to WordPress through it. Start with the API reference or the full integration story on /ai-agents.

Ship the first post in minutes.

Connect WordPress, point your agent at the MCP server (or just write in the editor), and publish. Free to start — no credit card needed.

Start free