> For the complete documentation index, see [llms.txt](https://docs.storylane.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.storylane.io/integrations-demo-suite/integrations-and-data-flow/mcp.md).

# MCP

Storylane MCP connects Claude, ChatGPT, Microsoft Copilot, Cursor,  and other MCP-compatible AI clients to your account. Personalize, analyze, and publish demos without leaving your AI client.

* [Storylane MCP overview](#storylane-mcp-overview)
* [Setup and clients](#connect-your-ai-client)
* [Available tools](#available-tools)
* [AI workflows](#ai-workflows)
* [Ready-to-use prompts](#prompt-library)
* [FAQ](#faq)

***

### Storylane MCP overview

Connect Claude, ChatGPT, Microsoft Copilot other MCP-compatible AI clients to Storylane.

Use natural-language prompts to manage your demo library. Build, personalize, analyze, and publish demos without leaving your AI client.

{% hint style="info" %}
The MCP server URL: <https://mcp.storylane.io/mcp>
{% endhint %}

{% @storylane/embed subdomain="app" linkValue="a8s4jaoeaa0o" url="<https://app.storylane.io/share/a8s4jaoeaa0o>" %}

What you can do:

* **Analyze engagement.** Query demo performance, leads, and account activity.
* **Create demos from media.** Convert screenshots or recordings into interactive demos.
* **Personalize at scale.** Create tailored demo variants and trackable links.
* **Manage your library.** Browse demos, workspaces, hubs, links, and voices.
* **Publish and distribute.** Update demos, publish them, and manage share links.

### Connect your AI client

Two ways to connect, depending on how you work.

#### 1. Public LLM clients

For Claude, ChatGPT, and Microsoft Copilot. Uses OAuth — no API keys required.

{% tabs %}
{% tab title="Claude" %}

1. In Claude, open **Settings → Connectors**.
2. Select **Add custom connector**.
3. Paste the Storylane MCP server URL.
4. Sign in to Storylane and approve access.
5. In a conversation, select **+ → Connectors** and enable Storylane.
6. Open connector settings and set **Tool permissions** to **Always allow** — this lets workflows run end to end without stopping to ask for confirmation on every action.

{% hint style="info" %}
**For Personal Accounts:** "Add Custom Connector" is always available.

**For Company Accounts:** "Add Custom Connector" is only available for account admins. A non-admin member cannot add a Custom Connector in a Company Account.
{% endhint %}
{% endtab %}

{% tab title="ChatGPT" %}

1. For write actions, enable Developer Mode in **Workspace Settings → Permissions & Roles → Connected Data**.
2. Open **Settings → Apps & Connectors** and create a connector.
3. Set the name to `Storylane`.
4. Select OAuth authentication and add the Storylane MCP server URL.
5. Publish the connector, then authorize it from **Apps & Connectors**.

{% hint style="info" %}
**Free accounts:** Custom Connector is not available.

**Personal (paid) accounts and company accounts:** Custom Connector is available.
{% endhint %}

{% hint style="warning" %}
Write actions require Developer Mode. It is currently in beta for Business and Enterprise plans. Read-only tools work on all plans.
{% endhint %}
{% endtab %}

{% tab title="Microsoft Copilot" %}

1. In Microsoft Copilot Studio, open your agent and go to **Tools → Add tool → New tool**.
2. Select **Model Context Protocol**.
3. Paste the Storylane MCP server URL.
4. Under **Connection**, select **Create new connection**, then sign in to Storylane and approve access.
5. Save the tool, then publish or roll out the agent to yourself or your team.

{% hint style="info" %}
Unlike Claude or ChatGPT, Microsoft Copilot doesn't have a direct "Settings → Connectors" toggle — MCP servers are added through Copilot Studio and made available via an agent your org publishes or rolls out to users.
{% endhint %}
{% endtab %}
{% endtabs %}

#### 2. M2M authentication

For Cursor, n8n, custom automations, and any tool that connects via client credentials. Use M2M when you need server-to-server access without a user session.

Go to **Settings → Integrations → MCP** and click **Request credentials** to generate your `client_id` and `client_secret`. Credentials are unique to your account and workspace.

{% hint style="warning" %}
Store your `client_secret` securely — it is only shown once. If exposed, generate new credentials from **Settings → Integrations → MCP** and revoke the old ones.
{% endhint %}

**Cursor and similar platforms**

Add the following to your `mcp.json` file:

```json
{
  "mcpServers": {
    "storylane": {
      "name": "Storylane",
      "description": "Storylane MCP",
      "url": "https://mcp.storylane.io/mcp"
    }
  }
}
```

{% hint style="info" %}
M2M credentials are scoped to your account and workspace. `switch_workspace` and `list_workspaces` are not available to M2M clients for security reasons.
{% endhint %}

### Available tools

Every tool is scoped to your workspace. Your AI client only accesses data you can access.

#### Analytics

* `get_demo_analytics` — Get views, unique visitors, session duration, CTA clicks, click-through rate, and completion rate for a demo.
* `get_accounts` — List companies that engaged with demos, including firmographic and engagement data.
* `get_leads` — Get leads captured through demo gating forms and their source demos.

#### Demo library

* `list_workspaces` — List workspaces available to the authenticated user.
* `switch_workspace` — Change the active workspace for the current session.
* `list_demos` — List demos in the active workspace. Supports filtering and search.
* `get_demo` — Get a demo's status, last published data, default link, and any labels added to it.&#x20;
* `get_demo_status` — Get a demo's publish and processing status.

#### Demo creation and editing

* `convert_images_to_demo` — Create an interactive demo from uploaded images or screenshots.
* `convert_video_to_demo` — Create an interactive demo from a screen recording or video.
* `add_step` — Add a text, hotspot, or tooltip step to an existing demo.
* `personalise_demo` — Create an AI-personalized demo variant for a company, persona, or context.
* `update_demo_settings` — Update a demo's Convert CTA configuration and nav bar capabilities&#x20;
* `publish_demo` — Publish a draft or updated demo.

#### Hubs

* `list_hubs` — List Demo Hubs in the active workspace.
* `get_hub` — Get a hub's demos, ordering, branding, and share URL.

#### Links and distribution

* `list_links` — List share links, tracking variables, creation dates, and view counts.
* `create_link` — Create a trackable demo link with custom variables.
* `update_link` — Update an existing link's variables, expiry, or access settings.

#### Voices

* `list_voices` — List available AI voices, languages, voice IDs, and preview URLs.

### AI workflows

{% hint style="info" %}
26 prompts, ready to paste. [Explore the full MCP library here](https://www.storylane.io/mcp).
{% endhint %}

#### Product marketing

**Create a launch demo from media**

1. Upload screenshots or a screen recording.
2. Create the demo with `convert_images_to_demo` or `convert_video_to_demo`.
3. Check completion with `get_demo_status`.
4. Set the title, description, branding, and gating with `update_demo_settings`.
5. Publish it with `publish_demo`.

Pair this workflow with Linear or Jira. Create demos from completed feature tickets.

**Audit your demo library**

1. List published demos with `list_demos`.
2. Retrieve analytics for each demo with `get_demo_analytics`.
3. Rank demos by engagement.
4. Flag low-performing demos for updates, personalization, or retirement.

Try this prompt:

> List all published demos. Show demos below 40% completion that had no views in 30 days. Rank them worst to best. Recommend an action for each.

#### Sales and account executives

**Prepare a personalized demo before a call**

1. Find relevant demos with `list_demos` and `get_demo`.
2. Create an account-specific variant with `personalise_demo`.
3. Publish it with `publish_demo`.
4. Generate a trackable link with `create_link`.

Combine this workflow with HubSpot or Salesforce. Log the generated link on the contact record.

**Prioritize follow-ups from engagement**

1. Get recent leads with `get_leads`.
2. Review account activity with `get_accounts`.
3. Rank accounts by engagement.
4. Draft follow-up actions for hot, nurturing, and inactive accounts.

#### Sales engineers

**Convert a screen recording into a demo**

1. Convert the recording with `convert_video_to_demo`.
2. Add missing steps with `add_step`.
3. Select narration options with `list_voices`.
4. Publish the demo and create a prospect link.

**Plan an enterprise deal hub**

1. Find persona-relevant demos with `list_demos` and `get_demo`.
2. Review existing hubs with `list_hubs` and `get_hub`.
3. Personalize selected demos with `personalise_demo`.
4. Create a recommended hub structure for the buying committee.

#### Customer success

**Refresh stale onboarding demos**

1. List onboarding and help demos with `list_demos`.
2. Find low-engagement demos with `get_demo_analytics`.
3. Prioritize demos to update, recreate, or retire.

**Identify customer expansion signals**

1. Query customer engagement with `get_accounts`.
2. Check demo-level activity with `get_demo_analytics`.
3. Flag customers exploring advanced features for follow-up.

#### RevOps and marketing operations

**Send a personalized demo when a deal reaches Demo stage**

1. Trigger the workflow from a CRM stage change.
2. Find a relevant demo with `list_demos`.
3. Personalize it using CRM data with `personalise_demo`.
4. Publish the demo and create a tracked link.
5. Write the link back to the CRM record.

Use HubSpot, Salesforce, Zapier, or webhook workflows as the trigger.

### Prompt library

26 prompts, ready to paste. Pick one to see what it does and copy the prompt. Swap anything in \[brackets]. Here are a few of our favorites. [Explore the full MCP library here](https://www.storylane.io/mcp).

### Weekly report → Slack <a href="#dtitle" id="dtitle"></a>

A ranked digest in the same shape each week, with movement called out — not a wall of metrics. Copy and paste the following:

```
Using the Storylane MCP, build this week's demo performance report.

1. Pull demo analytics for the last 7 days and compare against the previous 7. Exclude internal team views — I only want real prospect sessions.
2. Take the top 5 demos by sessions. For each, capture sessions, engagement rate, CTA clicks, and the change vs last week.
3. Also flag the single biggest mover, even if it sits outside the top 5.
4. Use demo names, never IDs.

Format it exactly like this, every week:

Storylane demos — week of [date]
Top 5 by sessions
1. [name] — [n] sessions ([+/-]%) · [x]% engaged · [n] CTA clicks
Biggest mover: [name] [+/-]% — [what changed, one clause]
Watch: [one demo with a drop or weak progression, one line]

Then post it to [#marketing]. Ignore moves under 10% as noise.
```

#### Personalized leave-behind

A personalized demo, tracked link, CTA set, and an opener ready to send. Copy and paste the following:

```
Using the Storylane MCP, build a leave-behind demo after my call.

Company: [NAME] — [industry]
They cared about: [TOPICS]
Objection raised: [OBJECTION]
Base demo: [DEMO NAME]

1. Work on a copy — never edit the original.
2. Personalize it for this company: emphasize what they cared about, address the objection, keep the tone confident and concise. Tie it to something specific from the call, not just the company name.
3. Poll until personalization completes.
4. Publish the copy — it stays a draft with no shareable link until you do.
5. Set the CTA to "[Book a follow-up]" pointing at [MY BOOKING LINK]. Copies inherit the base demo's CTA, so always set this explicitly.
6. Create a tracked share link with the company name as a variable.

Give me the link plus a two-sentence follow-up opener I can send as-is.
```

#### Demo attribution

Sourcing demos separated from assisting ones, with the gating caveat stated. Copy and paste the following:

```
Using the Storylane MCP, show me which demos actually source pipeline.

1. Pull leads from the last 90 days three ways: first-touch (Attributed), multi-touch (Nurtured), and Direct.
2. Group them by the demo they came from. Use demo names, not IDs.
3. Rank demos by first-touch leads, but show the full source mix for each.

Output a table: demo, first-touch, nurtured, direct, total. Then name the best sourcing demo and the best assister separately — they're different things.

Important: leads only exist where a demo or link is gated. Flag that ungated demos will under-count, rather than implying they underperform.
```

#### Compare demo performance

> Which Storylane demos had the highest engagement rate over the past 30 days? Show views, completion rate, and CTA clicks for each.

Uses `list_demos` and `get_demo_analytics`.

#### Find engaged accounts

> Show accounts that engaged with our demos in the last two weeks. Rank them by total time spent and list the demos they viewed.

Uses `get_accounts` and `get_demo_analytics`.

#### Personalize a demo for a prospect

> Find the best demo for a \[industry] company focused on \[use case]. Personalize it for \[Company Name]. Create a tracked link with their name and email.

Uses `list_demos`, `personalise_demo`, `publish_demo`, and `create_link`.

#### Create a demo from a recording

> Convert this screen recording into a Storylane demo. When it is ready, add a final step for \[feature name], then publish it.

Uses `convert_video_to_demo`, `get_demo_status`, `add_step`, and `publish_demo`.

#### Audit inactive demos

> List published demos. Flag those with no views in 30 days or completion below 30%. Recommend whether to update, personalize, or retire each one.

Uses `list_demos` and `get_demo_analytics`.

#### Review Demo Hubs

> Show every Demo Hub and its demos. Identify hubs missing a demo for the \[persona] persona. Suggest existing demos to add.

Uses `list_hubs`, `get_hub`, and `list_demos`.

#### Follow up with captured leads

> Who submitted a demo gating form this week? Group them by source demo. Draft a personalized follow-up for the top three leads.

Uses `get_leads` and `get_demo`.

### FAQ

#### **👉 How can I reduce token usage?**

Most token usage comes from two places: the tool definitions your AI client loads, and the data each tool returns. To keep usage low:

* **Enable only the tools you need.** Each enabled tool adds to every request. Most clients let you turn off individual tools in the connector settings.
* **Be specific.** Name the demo, date range, or account in your prompt. "Analytics for \[demo name], last 30 days" costs far less than "How are my demos doing?", which makes the agent list and check everything.
* **Use the lightest tool.** For example, use `get_demo_status` instead of `get_demo` when you only need to know if processing is done.
* **Narrow large queries.** Add filters, date ranges, or result limits to `list_demos`, `get_leads`, `get_accounts`, and analytics requests.
* **Start a new chat for each task.** Long conversations resend earlier tool results with every message.
* **Use a smaller model for routine tasks.** Pulling leads or creating links doesn't need your most capable model.

#### 👉 Do I need technical skills?

No. After the connector is configured, use plain-language prompts.

#### 👉 Which AI clients are supported?

Claude, ChatGPT, Microsoft Copilot are supported.

#### 👉 Can an agent access another workspace?

No. Operations use the active workspace. Use `switch_workspace` when you have access to multiple workspaces.

#### 👉 Is my content secure?

MCP access uses OAuth. Your AI client never receives your Storylane password.

You can revoke access from **Settings → Connectors**. Agents only access workspace data allowed by your permissions.

#### 👉 How do `personalise_demo` and link variables differ?

`personalise_demo` creates a new demo variant with AI-adapted content.

`create_link` adds dynamic viewer variables to a tracked URL. It does not modify the demo.

#### 👉 Can I automate MCP workflows?

Yes. Trigger workflows with CRM events, Zapier, or other MCP-connected tools.

#### 👉 Does MCP support Hubs?

You can list hubs and read their structure. Hub creation and editing are coming soon.

#### 👉 Which plan includes MCP?

MCP is available on Starter plan and above. Check **Settings → Integrations → MCP** for access.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.storylane.io/integrations-demo-suite/integrations-and-data-flow/mcp.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
