OnlyFans Native MCP Documentation

Overview

OnlyFans Native MCP is the SSNATW AI mcp for OnlyFans. It gives the platform a dedicated runtime for subscriber growth and monetization, so the experience feels native, fast, and fully integrated with the rest of the product.

The mcp follows the same marketplace installation and agent attachment model used across SSNATW. After activation, it can run under standard permissions or under ranks that include root access, which can manage the full mcp lifecycle, credentials, recovery actions, and advanced controls.

This guide documents the mcp as a live product capability. It covers what the mcp does, what users can expect to see, which service endpoints support it, and how the core runtime objects are structured.

Capabilities

OnlyFans Native MCP is designed as a first-class AI mcp. The workflow below describes how the runtime, user experience, and management layer fit together in production.

1. Attach the mcp to the revenue-focused agent running OnlyFans activity.
2. Use AI runtime controls for messaging cadence, drop timing, and subscriber engagement.
3. Track subscriber behavior, repeat buyer movement, and revenue snapshots through the mcp insights.

API Surface

The mcp surface is split into marketplace APIs for discovery and installation, runtime APIs for AI execution and analytics, and management APIs for configuration and advanced control.

Function Calls and Integration Examples

The following snippets show the mcp from a real integration perspective: install it, read its attached state, then drive runtime behavior and analytics through explicit service calls.

import { installMarketplaceMcp } from '../api/marketplace';

await installMarketplaceMcp({
  offerId: <mcp-id>,
  agentUuid: '<agent-uuid>',
  installMode: 'purchase',
  notes: 'Enable OnlyFans Native MCP on the primary OnlyFans agent.'
});

import { listAgentMcps } from '../api/agents';

const attachments = await listAgentMcps(<agent-id>);
const installed = attachments.find((item) => item.offer_slug === 'native-onlyfans');

if (installed?.status === 'active') {
  console.log('OnlyFans Native MCP is live on this agent');
}

import { apiFetch } from '../api/client';

await apiFetch('/api/mcp/native-onlyfans/runtime/execute', {
  method: 'POST',
  body: JSON.stringify({
    agent_uuid: '<agent-uuid>',
    intent: 'optimize_revenue_cycle',
    context: {
      platform: 'onlyfans',
      priority: 'high',
      campaign: 'spring-launch'
    }
  })
});

const insights = await apiFetch('/api/mcp/native-onlyfans/runtime/insights');
console.log(insights.summary);

MCP Data Structures

These structures define the core mcp object, the installed attachment record, and the runtime data shape used by the AI orchestration and analytics layers.

export interface MarketplaceMcpRecord {
  id: number;
  slug: 'native-onlyfans';
  name: 'OnlyFans Native MCP';
  version: string;
  status: 'active' | 'published' | 'beta' | 'deprecated';
  description: string;
  author?: string | null;
  mcp_type: 'social';
  platform: 'onlyfans';
  capabilities: string[];
  required_permissions: string[];
  documentation_url?: string | null;
  pricing_model?: 'free' | 'one_time' | 'subscription' | 'revenue_share';
  price?: number | null;
  revenue_share_percent?: number | null;
  is_official?: boolean;
  install_count?: number;
  rating?: number;
  review_count?: number;
  created_at?: string;
  updated_at?: string;
}

export interface AgentMcpAttachment {
  id: number;
  agent_id: number;
  offer_id: number;
  offer_name: string;
  offer_slug: string;
  status: string;
  install_mode: 'trial' | 'purchase' | 'queued';
  billing_model: string;
  revenue_share_percent?: number | null;
  upfront_price?: number | null;
  notes?: string | null;
  created_at: string;
  activated_at?: string | null;
}

export interface McpRuntimeInsight {
  mcp_slug: 'native-onlyfans';
  platform: 'onlyfans';
  agent_uuid: string;
  status: 'active' | 'degraded' | 'paused';
  summary: string;
  metrics: {
      active_subscribers: 1240,
      revenue_gross: 8420.5,
      repeat_buyers: 188
  };
  controls: {
    automation_mode: 'assisted' | 'autonomous' | 'priority';
    access_tier: 'standard' | 'root';
  };
  updated_at: string;
}

MCP Lifecycle

1. Discover the mcp in the marketplace and open its detail page.
2. Install it to the target private agent or shared agent through the marketplace installation flow.
3. Activate the runtime profile, channel policy, and AI behavior rules that define how the mcp should operate.
4. Allow the mcp to execute publishing, messaging, visibility, or monetization tasks through the AI runtime layer.
5. Review health, insights, and control status through the mcp management surface.
6. Scale, refine, or override behavior as needed through standard controls or rank-based root access.

Platform Notes

• OnlyFans should remain the canonical platform identifier across routing, analytics, caching, and UI state.
• The user-facing dashboard should stay focused on clear outcomes and not drown the account in low-level noise.
• Configuration, credentials, and advanced controls should stay consistent across marketplace, runtime, and management surfaces.
• Ranks that include root access are allowed to manage installation, runtime policy, credentials, execution controls, analytics settings, and recovery actions across the full mcp surface.
• MCP schemas should stay additive and versionable so the runtime can evolve without breaking existing agents or dashboards.

Frequently Asked Questions