> ## Documentation Index
> Fetch the complete documentation index at: https://docs.usequotable.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Workflows

> Multi-step recipes that combine the Quotable MCP server with the other tools in your AI client: weekly briefs, outreach lists, content briefs, agent runs and scheduled reports.

The Quotable MCP server reads your data and can start your Quotable agents. Your AI client does the rest: it reasons over the results, writes files, and, if you've connected them, uses other tools such as Slack, Notion or Google Drive. These recipes show how the pieces fit.

> [!WARNING]
>
> The only thing Quotable's MCP server can change is starting an agent run, with `run_agent`. It can't send messages, post to Slack or write documents, and an agent with steps that act outside Quotable runs only from the app. Any step that writes somewhere else uses a connector or tool **in your AI client**, set up and authorized by you, under that tool's own permissions and terms. Quotable doesn't provide, operate or see those connectors.

## Weekly visibility brief to Slack or Notion

Turn a week of tracking into a short update for your team.

**You need:** a key with `read:projects` and `read:visibility`, and a Slack or Notion connector in your AI client (for example, a connector added in Claude).

**1. Pull the numbers**

```text theme={"system"}
Using Quotable, get Acme's daily visibility for the last 14 days. Compare the last 7 days with the 7 before: average visibility score, average mention rate and Acme's average share of voice. Rank the top five brands by share of voice for the last 7 days.
```

**2. Add the sources**

```text theme={"system"}
Now list the 20 pages AI answers cite most for Acme, and note any that were last seen in the past 7 days.
```

**3. Write and send the brief**

```text theme={"system"}
Write a brief of at most 150 words: one headline sentence, three bullet points on what changed, and one recommended action. Then post it to the #ai-visibility Slack channel.
```

Your client asks for permission before it uses the Slack connector. To publish to Notion instead, ask it to create a page in your team's wiki.

> [!TIP]
>
> Review the brief before you approve the post. Your assistant writes it from the numbers, and you're the one sending it.

## Outreach list of cited sources

Find the publications and communities AI engines rely on, and turn them into a list your PR or content team can work through.

**You need:** a key with `read:projects` and `read:visibility`. Optionally a spreadsheet connector, or a client that can write files, such as Claude Code or Cursor.

**1. Collect cited pages**

```text theme={"system"}
Using Quotable, list the 100 most cited pages for Acme. Leave out acme.com and the domains of brands we compete with.
```

**2. Classify and prioritize**

```text theme={"system"}
Group the pages by domain. For each domain give total times cited, number of pages, the most recent last-seen date, and a type: review site, publication, community, directory or other. Sort by times cited.
```

**3. Save it**

```text theme={"system"}
Save this as outreach.csv with columns domain, type, times_cited, pages, last_seen, top_url.
```

In Claude Code or Cursor, the client writes the file in your project. With a spreadsheet connector, ask it to create a sheet instead.

## Content briefs in your repository

If your site lives in a repository, let your coding assistant draft briefs next to your content.

**You need:** a key with `read:projects` and `read:visibility`, in Claude Code, Cursor or VS Code.

**1. Find the gaps**

```text theme={"system"}
Using Quotable, list Acme's active prompts with their demand scores. Compare them with the posts in content/blog/ and find the five prompts with the highest demand score that no existing post covers.
```

**2. Ground each brief in what AI cites**

```text theme={"system"}
List the 50 most cited pages for Acme. For each of the five prompts, pick the cited pages most relevant to it and note what they cover.
```

**3. Write the briefs**

```text theme={"system"}
For each prompt, create a Markdown file in content/briefs/ with: the prompt, the search intent, a proposed title, an outline of H2s, the sources AI currently cites for this topic, and what our page must cover to be worth citing. Match the tone of the existing posts in content/blog/.
```

> [!NOTE]
>
> Citations are reported per brand, not per prompt, so your assistant matches pages to prompts by topic. Treat its matches as a starting point.

## Scheduled report from the command line

Claude Code can run a prompt without an interactive session, which lets you schedule a report with cron or your CI system.

**You need:** Quotable added to Claude Code (see [Claude Code](https://docs.usequotable.com/mcp-server/connect/claude-code.md)) on the machine that runs the job, with a key that has `read:projects` and `read:visibility`.

```bash theme={"system"}
claude -p "Using Quotable, summarize Acme's visibility for the last 7 days versus the 7 days before, and list the five most cited domains. Output Markdown only." \
  --allowedTools "mcp__quotable__list_projects,mcp__quotable__get_visibility,mcp__quotable__list_citations" \
  > reports/visibility-$(date +%F).md
```

`--allowedTools` pre-approves the three Quotable tools this report needs, so the run doesn't stop to ask for permission. Name the tools rather than allowing all of `mcp__quotable`, which would also pre-approve `run_agent`. Use a dedicated key for automation, and revoke it when you retire the job.

## Run an agent from your client

Start one of your Quotable agents from a conversation and read its result when it finishes.

**You need:** a connection with `read:projects`, `read:agents` and `run:agents`, or an API key. Agents must be turned on for your workspace.

**1. Pick the agent**

```text theme={"system"}
Using Quotable, list Acme's agents and show me the inputs the competitor research agent needs.
```

**2. Start the run**

```text theme={"system"}
Run it for Globex.
```

Your client asks before it calls `run_agent`. The run uses your workspace's credits. Agents with steps that act outside Quotable, such as posting to Slack, can't be started here; start them in the app.

**3. Read the result**

```text theme={"system"}
Check the run until it finishes, then summarize the result in five bullet points.
```

A run that waits for someone to approve a step shows as `paused` until it's approved in the app.

## Agency rollup across brands

If you manage several brands in one workspace, compare them in one pass.

**You need:** a key with `read:projects` and `read:visibility`, limited to the brands you report on.

```text theme={"system"}
Using Quotable, list all my brands. For each one, get the last 30 days of visibility and give me one table: brand, average score, change versus the previous 30 days, and the competitor with the highest share of voice. Sort by change, worst first.
```

Each brand is at least one tool call, and every call counts toward the key's limit of 300 requests per minute. A rollup across dozens of brands fits comfortably.

## Next steps

> [card] [Example prompts](https://docs.usequotable.com/mcp-server/example-prompts.md)
>
> Single prompts to start from.

> [card] [Troubleshooting](https://docs.usequotable.com/mcp-server/troubleshooting.md)
>
> Errors and what they mean.

> [card] [Tools reference](https://docs.usequotable.com/mcp-server/tools.md)
>
> What each tool returns.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.