Gentic Subscriptions — Documentation

1. Getting Started

Sign Up & Get Your API Key

Before you can use Gentic Subscriptions, you need an API key to authenticate your requests.

1. Go to gentic.co/subscriptions and create an account.
2. Create an organization from your dashboard. API keys and billing are scoped to the organization.
3. Generate an API key and use it as a Bearer token in your MCP client.

2. Connecting to the MCP Server

The server is available at https://mcp.gentic.co/subscriptions. For Claude Code:

claude mcp add gentic-subscriptions \
  --transport http \
  https://mcp.gentic.co/subscriptions \
  --header "Authorization: Bearer YOUR_API_KEY"

For Claude Web and ChatGPT you can also connect via OAuth — no API key needed. See the connect section on the landing page for other MCP clients (n8n, OpenClaw).

3. Agent Skill

For the best results, pair the MCP server with the Gentic Subscriptions agent skill. The MCP server gives your agent tool access; the skill teaches it the optimal workflow order. Both the raw SKILL.md and a ready-to-upload .skill bundle are generated on demand from the live manifest, so they always reflect the current tools and pricing.

Add the skill directly via URL:

https://gentic.co/subscriptions/SKILL.md

Or upload a .skill bundle to Claude Managed Agents:

https://gentic.co/subscriptions/gentic-subscriptions.skill

Download this file and upload it wherever Claude Managed Agents asks for a .skill file. It's a zip bundle generated on demand from the latest SKILL.md.

4. When to Apply

• User wants to know their active subscriber count, MRR, or recurring-revenue trends.
• User wants to understand churn — why subscribers are cancelling, or the top cancellation reasons.
• User wants to find revenue at risk from failed payments / dunning (billing attempts).
• User wants to sync their Loop subscription data into their Brain for analysis.
• User wants to count or aggregate over subscriptions, orders, billing attempts, or cancellations.
• User wants to feed subscription metrics into a digest, retention flow, or revenue report.

5. Workflow

1. 1. Connect Loop once, then sync without credentials

   The Subscriptions server sources the Loop connection (the Admin API token) from the org's connected integration (Gentic dashboard → Integrations → Loop). You never pass credentials to the tools — connect once in the dashboard and the server reads the encrypted connection automatically. Call `loop_connection_status` first (it's free) to confirm the org is connected; if it returns `{ connected: false }`, point the user to Integrations → Loop. It never returns the API token.

2. 2. Sync subscription data into the Brain with `loop_sync`

   `loop_sync` is **free**. It is READ-ONLY and warehouses four resources into per-org tables — `loop_subscriptions`, `loop_orders`, `loop_billing_attempts`, `loop_cancellation_reasons` — dedupe-upserted on their natural key, so a re-sync refreshes existing rows in place rather than duplicating them. Returns `{ synced: { <resource>: count }, has_more, next_cursor, persisted }`.

3. 3. Walk the data with bounded, resumable pagination

   Each `loop_sync` call is BOUNDED: it pages the requested resources only until `max_pages_per_run` pages OR `max_seconds_per_run` seconds are reached, then returns `has_more` and a `next_cursor: { resource, page_no }`. To finish a large backfill, call again passing that `next_cursor` back as `cursor` until `has_more` is false — the walk resumes exactly where it stopped. Use `resources` to sync only the tables you need and `page_size` to tune batch size.

4. 4. Count and aggregate with `query_data`

   The subscription tools warehouse data; they don't analyze it. For subscriber counts, MRR, churn rate, cancellation-reason breakdowns, or failed-payment totals, use `query_data` (Gentic Data MCP) over the `loop_subscriptions`, `loop_orders`, `loop_billing_attempts`, and `loop_cancellation_reasons` tables — standard SQL GROUP BY / COUNT / SUM over the synced rows. Sync first (or re-sync incrementally) so the numbers are current.

5. 5. Join across your other synced data

   Because everything lands in the same per-org Brain, you can join subscription data with what you've synced from other Gentic servers — e.g. correlate cancellation reasons with support tickets (`support_tickets`), or subscriber cohorts with order history. Compose the question across tables with `query_data`.

6. 6. Present results clearly

   Don't dump raw JSON. Summarize the numbers — active subscribers, MRR, top cancellation reasons, revenue at risk — and cite the counts. After a sync, tell the user how many rows were `persisted` per resource and whether `has_more` is true (i.e. there's more to page through). For recurring checks, re-run `loop_sync` to refresh the tables before querying.

6. Tool Reference

2 tools, rendered live from the Gentic MCP manifest. Parameter tables come directly from each tool's JSON Schema.

7. Pricing

Pricing is pulled live from the Gentic MCP manifest. All prices are per call and deducted from your Gentic credits.

8. Notes

• Organization-scoped: the Loop connection comes from the org's connected integration (dashboard → Integrations → Loop). No credential is ever passed to the tools.
• Cost: both `loop_connection_status` and `loop_sync` are **free**. You pay only for analytics you run over the synced data (e.g. `query_data`). Pricing is pulled live from the Gentic MCP manifest.
• `loop_sync` is READ-ONLY — it warehouses Loop data into your Brain and never writes back to Loop.
• Rows are deduped on their natural key: re-syncing refreshes the same row (mutable fields and all) rather than duplicating it.
• Syncs are bounded and resumable: each call stops at `max_pages_per_run` / `max_seconds_per_run` and returns `next_cursor`; pass it back as `cursor` to continue. Loop `has_more` to false to finish a backfill.
• The four tables — `loop_subscriptions`, `loop_orders`, `loop_billing_attempts`, `loop_cancellation_reasons` — are queried with `query_data` for all counts and aggregations.