# Contact us
Source: https://docs.kepler.ai/contact

How to reach the Kepler team for help, access, and feedback.

We are here to help you get the most out of Kepler. Pick the channel that fits what you need.

<CardGroup>
  <Card title="Support" icon="life-ring" href="mailto:support@kepler.ai">
    Questions, bug reports, or trouble connecting the MCP connector. Email [support@kepler.ai](mailto:support@kepler.ai).
  </Card>

  <Card title="Access and accounts" icon="key" href="mailto:support@kepler.ai">
    Need MCP access enabled, or have a question about your account? Reach out to your Kepler contact, or email [support@kepler.ai](mailto:support@kepler.ai).
  </Card>

  <Card title="Open Kepler" icon="arrow-up-right-from-square" href="https://app.kepler.ai">
    Sign in and run research at [app.kepler.ai](https://app.kepler.ai).
  </Card>

  <Card title="Stay in the loop" icon="x-twitter" href="https://x.com/kepler_ai">
    Follow [@kepler\_ai](https://x.com/kepler_ai) for product news, or visit [kepler.ai](https://kepler.ai).
  </Card>
</CardGroup>

## Reporting an issue

When you email support, a few details help us resolve things faster:

* The MCP client you are using, for example Claude, ChatGPT, or Cursor.
* What you asked and what happened, including any error message.
* The `conversation_id` if a specific run was involved. Your assistant can read it back to you, or you can find the run in the Kepler app.

<Tip>
  Not sure whether something is a connector issue or a coverage gap? Ask Kepler to check availability first with [`lookup_company`](/mcp/tools#lookup_company). It returns instantly and confirms what filings and transcripts Kepler has on file.
</Tip>


# Frequently asked questions
Source: https://docs.kepler.ai/faq

Common questions about Kepler and the MCP connector.

## About Kepler

<AccordionGroup>
  <Accordion title="What is Kepler?">
    Kepler is an AI financial research agent. It reads primary sources, SEC filings (XBRL), earnings call transcripts, and market data, and returns answers and spreadsheet models where every figure is backed by a citation you can audit. Use it in the [Kepler app](https://app.kepler.ai) or through the [MCP connector](/mcp/overview).
  </Accordion>

  <Accordion title="What is the MCP connector?">
    The connector is a remote [MCP](https://modelcontextprotocol.io) server that lets AI assistants such as Claude, ChatGPT, and Cursor run Kepler research on your behalf. You add it to your client once, and from then on your assistant can return the same citation-backed answers and workbooks you would get in the app, from inside any conversation. See the [connector overview](/mcp/overview).
  </Accordion>

  <Accordion title="How is this different from asking my assistant directly?">
    Your assistant's own knowledge is dated and uncited, and web summaries are secondary sources. Kepler reads the actual filings and transcripts and links every figure to the document it came from, so results are auditable. When work has to be right, the citations are the point.
  </Accordion>
</AccordionGroup>

## Access and setup

<AccordionGroup>
  <Accordion title="How do I get access?">
    MCP access is rolled out per account. If your client reports that access is not enabled after you sign in, ask your Kepler contact to enable it, then sign out of Kepler and back in so your session picks up the change. See [access](/mcp/overview#access).
  </Accordion>

  <Accordion title="Which clients work with the connector?">
    Any client that supports remote MCP servers over streamable HTTP, including Claude, Claude Code, ChatGPT, Cursor, and VS Code. See [connect a client](/mcp/connect) for step-by-step setup for each.
  </Accordion>

  <Accordion title="Do I need an API key?">
    No. The connector signs you in with OAuth 2.1 using your Kepler account. There are no API keys to create, paste, or rotate. See [security and access](/mcp/overview#security-and-access).
  </Accordion>

  <Accordion title="What is the connector URL?">
    `https://mcp.kepler.ai/api/mcp/v1`. You can also copy it from the **MCP** page in the Kepler app sidebar, which always shows the current URL and setup steps.
  </Accordion>
</AccordionGroup>

## Coverage and data

<AccordionGroup>
  <Accordion title="What companies and data does Kepler cover?">
    Publicly listed companies, through their SEC filings and earnings call transcripts, plus market data. The connector works with the same coverage as the Kepler app.
  </Accordion>

  <Accordion title="How do I check whether a company or filing is available?">
    Ask an availability question, for example *"Use Kepler to check whether Nvidia's latest 10-K and Q3 call are available."* This calls [`lookup_company`](/mcp/tools#lookup_company) and returns instantly, with no run required. It lists the filings and transcripts Kepler has on file, with forms, dates, and fiscal periods.
  </Accordion>

  <Accordion title="Can Kepler research private companies?">
    No. Kepler works from public filings and transcripts, so coverage is limited to publicly listed companies.
  </Accordion>
</AccordionGroup>

## Running research

<AccordionGroup>
  <Accordion title="How long does a run take?">
    Usually a few minutes, and longer for larger models, because Kepler reads primary sources rather than summarizing from memory. Your assistant holds the connection open and streams progress while it works, so you see what Kepler is reading rather than a spinner.
  </Accordion>

  <Accordion title="Can I follow up or refine a result?">
    Yes. Follow-ups stay in the same conversation, so Kepler keeps full context from earlier runs. Ask for a new column, a broken-out segment, or a different period, and your assistant extends the existing run with [`continue_research`](/mcp/tools#continue_research).
  </Accordion>

  <Accordion title="How do I get a spreadsheet or export the data?">
    Ask for a model and the result includes a workbook you can open in the app or download as `.xlsx`. To pull a sheet for downstream analysis, ask for it as CSV, and your assistant calls [`get_workbook_data`](/mcp/tools#get_workbook_data). Every cell traces back to a source.
  </Accordion>

  <Accordion title="Can I find and continue an earlier run?">
    Yes. Ask for something like *"the Netflix model I built yesterday,"* and your assistant calls [`list_recent_runs`](/mcp/tools#list_recent_runs) to locate the conversation, then continues it. No need to start over.
  </Accordion>

  <Accordion title="How do I stop a run I started by mistake?">
    Ask your assistant to cancel it. Cancelling is non-destructive: the conversation and any partial results survive, and you can re-engage it later with a follow-up. See [`cancel_run`](/mcp/tools#cancel_run).
  </Accordion>
</AccordionGroup>

## Citations and trust

<AccordionGroup>
  <Accordion title="How do citations work?">
    Every figure in an answer links back to the exact filing or transcript it came from. Open a citation to trace a number to its source. Results are auditable through these links, not a black box.
  </Accordion>

  <Accordion title="What is the sourcing report?">
    A coverage summary included with each result. It tells you how many figures are cited and whether every number in the answer is backed by a source, so you can see at a glance how much of an answer is sourced before you rely on it. See the [sourcing report shape](/mcp/tools#sourcing-report).
  </Accordion>
</AccordionGroup>

## Security

<AccordionGroup>
  <Accordion title="How does the connector authenticate?">
    With OAuth 2.1, using your Kepler account. There are no API keys to manage, and your sign-in token is validated at the edge rather than passed to the systems that run your research. See [data handling and privacy](/mcp/data-handling).
  </Accordion>

  <Accordion title="Is my research private to me?">
    Yes. Access is scoped to your account. Your assistant can reach only your own conversations and results, and no other user can see them. Your runs are saved to your account so you can revisit and continue them, the same as in the app.
  </Accordion>

  <Accordion title="Does the connector support enterprise SSO?">
    Yes. The connector signs in with your Kepler account, so your organization's SSO applies. Kepler supports enterprise SSO over SAML 2.0 and OIDC. See [single sign-on](/sso).
  </Accordion>

  <Accordion title="Is Kepler compliant with security standards?">
    Kepler is SOC 2 Type II certified, supports GDPR and CCPA, and has ISO 27001 in progress. See the [security page](https://kepler.ai/security) and [Trust Portal](https://trust.kepler.ai) for current details and documentation.
  </Accordion>

  <Accordion title="How is data stored, retained, and deleted?">
    Data handling is governed by Kepler's [Privacy Policy](https://kepler.ai/privacy) and [Terms](https://kepler.ai/terms). For a security review or vendor assessment, email [support@kepler.ai](mailto:support@kepler.ai).
  </Accordion>
</AccordionGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="My client says MCP access isn't enabled.">
    Access is granted per account. Ask your Kepler contact to enable it, then sign out of Kepler and back in so your session refreshes. More in [troubleshooting](/mcp/connect#troubleshooting).
  </Accordion>

  <Accordion title="The OAuth sign-in didn't appear.">
    Make sure you entered the full URL including the `/api/mcp/v1` path. A bare domain won't resolve the connector. Remove and re-add the server to trigger the sign-in again.
  </Accordion>

  <Accordion title="A run seems stuck.">
    Runs are meant to take a few minutes while Kepler reads sources. Your assistant waits and streams progress, and keeps waiting until a result or failure comes back. You can also continue the conversation or cancel the run.
  </Accordion>
</AccordionGroup>

## Still need help?

Reach out to your Kepler contact, or email [support@kepler.ai](mailto:support@kepler.ai).


# Glossary
Source: https://docs.kepler.ai/glossary

Key Kepler terms, defined once.

A quick reference for the terms used across these docs.

## Kepler

The AI financial research agent. Kepler reads primary sources, extracts the numbers, and returns answers and models where every figure is backed by a citation. Use it in the [Kepler app](https://app.kepler.ai) or through the [MCP connector](/mcp/overview).

## Primary sources

The documents Kepler reads to answer a question: SEC filings (XBRL), earnings call transcripts, and market data. Kepler works from these directly rather than summarizing from memory, which is what makes every figure auditable.

## Citation

A link from a figure in an answer back to the exact filing or transcript it came from. Open a citation to trace a number to its source. Citations are Kepler's core value, and results are auditable through these links.

## Sourcing report

The coverage summary included with each result. It shows what was cited and what wasn't, so you can see how much of an answer is backed by sources.

## Run

A single research execution. You ask a question, Kepler reads the relevant sources and builds the result, and the run completes, typically in a few minutes. A run is where the work happens.

## Conversation

An ongoing thread that can hold one or more runs. Follow-ups stay in the same conversation, so Kepler keeps full context from earlier runs. Through the connector, a conversation is identified by a `conversation_id`.

## Workbook

A spreadsheet artifact Kepler produces for model requests. Every cell traces back to a source. You can open a workbook in the app, download it as `.xlsx`, or export a sheet as CSV.

## Connector

The Kepler MCP integration. The connector is a remote MCP server you add to an AI assistant once; after that, your assistant can call Kepler's research tools from any conversation. See [the MCP connector docs](/mcp/overview).

## MCP

[Model Context Protocol](https://modelcontextprotocol.io), an open standard for connecting AI assistants to external tools and data. Kepler exposes its research as an MCP server so clients like Claude, ChatGPT, and Cursor can use it.

## Prompt

A pre-built starting point the connector ships with, surfaced as a slash command or quick action in some MCP clients. Prompts are a faster on-ramp to common tasks, and you can always ask in your own words instead. See [Prompts](/mcp/prompts).

## Coverage

The set of companies and documents Kepler can research: publicly listed companies through their SEC filings and earnings call transcripts. Check coverage for a specific company with the [`lookup_company`](/mcp/tools#lookup_company) tool, which answers instantly without a run.


# Welcome to Kepler
Source: https://docs.kepler.ai/index

AI financial research you can trust, and verify.

Kepler is an AI financial research agent built on a simple idea: an answer is only useful if you can prove it is right. It reads primary sources, SEC filings (XBRL), earnings call transcripts, and market data, and returns answers and spreadsheet models where every figure traces back to the document it came from. The difference is between AI that is probably right and AI that is provably right.

Ask a question in natural language and Kepler does the work: finding the right filings, extracting the numbers, building the model, and showing its sources. Use it in the [Kepler app](https://app.kepler.ai), or bring it into your AI assistant through the [MCP connector](/mcp/overview).

<Frame>
  <img alt="The Kepler app home, where you ask financial research questions in natural language" />
</Frame>

<CardGroup>
  <Card title="Quickstart" icon="rocket" href="/quickstart">
    Run your first research question and read a citation-backed answer.
  </Card>

  <Card title="MCP connector" icon="plug" href="/mcp/overview">
    Use Kepler from Claude, ChatGPT, Cursor, and other MCP clients.
  </Card>

  <Card title="Connect a client" icon="link" href="/mcp/connect">
    Add the Kepler connector to your assistant in a few steps.
  </Card>

  <Card title="Tools reference" icon="wrench" href="/mcp/tools">
    The full set of tools the connector exposes to your assistant.
  </Card>
</CardGroup>

## What you can ask

* **Company financials**: "What was NVIDIA's data center revenue last quarter, and how fast is it growing?"
* **Earnings recaps**: summaries of an earnings call against the filed results and prior guidance.
* **Financial models**: "Build a 3-statement model for Apple for the last three fiscal years."
* **Comparisons**: side-by-side fundamentals across two or more companies, every figure cited.

## Why citations matter

Kepler is built for work that has to be right. Every number in an answer links to the filing or transcript it came from, and each result includes a sourcing report so you can see what was cited and what wasn't. The model is auditable through the links, not a black box.


# Web app or connector
Source: https://docs.kepler.ai/mcp/app-vs-connector

When to use the Kepler app, when to use the MCP connector, and how they work together.

Kepler runs the same research engine whichever way you reach it. The [web app](https://app.kepler.ai) and the [MCP connector](/mcp/overview) draw on the same coverage, produce the same citation-backed answers and workbooks, and run against your same account. The difference is where you work.

## At a glance

|                    | Web app                                                  | MCP connector                                                                      |
| ------------------ | -------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| **Where you work** | The Kepler app at [app.kepler.ai](https://app.kepler.ai) | Inside your AI assistant (Claude, ChatGPT, Cursor, and others)                     |
| **Best for**       | Reading results, editing workbooks, browsing sources     | Research inline in a conversation, alongside your other tools                      |
| **Output**         | Interactive answers and workbooks you can open and edit  | The same answers and workbooks, returned into your chat with links back to the app |
| **Sign-in**        | Your Kepler account                                      | Your Kepler account over OAuth, no API keys                                        |
| **Setup**          | None, just sign in                                       | Add the connector once, see [connect a client](/mcp/connect)                       |

## Use the web app when

* You want the full interactive experience: open a workbook, edit it, and browse every source.
* You are reviewing or sharing results and want to trace citations in detail.
* You prefer a dedicated surface for research rather than a chat.

## Use the connector when

* You already work in an AI assistant and want research without leaving it.
* You want Kepler's cited numbers in the same place as your other context and tools.
* You are building an agent or workflow that should pull auditable financial data.

## Using both together

You do not have to choose. Runs live in your Kepler account, so a run you start through the connector shows up in the web app, and one you start in the app is reachable from the connector. Every result your assistant returns includes a link back to open the conversation or workbook in the app, so you can move between the two. Pick up an earlier run from either side and continue it with full context.

<Card title="Connect a client" icon="link" href="/mcp/connect">
  Add the Kepler connector to your assistant and start researching inline.
</Card>


# Best practices
Source: https://docs.kepler.ai/mcp/best-practices

Get faster, better-sourced results from Kepler through the connector.

Kepler does the research for you, but how you ask shapes what you get back. These practices help you get accurate, well-sourced results on the first try.

## Write a clear request

<AccordionGroup>
  <Accordion title="Name the company and the periods">
    "Apple's last three fiscal years" beats "Apple recently." Specific periods give Kepler a clear target and make citations easier to verify. A ticker or CIK removes any ambiguity about which company you mean.
  </Accordion>

  <Accordion title="Say what structure you want">
    For a model, describe the statement type, the segments, the periods, and any formatting up front. Asking for "a 3-year annual income statement with each line cited to its 10-K" is faster than building something generic and reshaping it afterward.
  </Accordion>

  <Accordion title="Ask for what you will check">
    If a specific number or driver matters, name it. "What drove the change in gross margin, with each figure cited" tells Kepler where to focus and what to source.
  </Accordion>
</AccordionGroup>

## Work efficiently

<AccordionGroup>
  <Accordion title="Check availability before a deep dive">
    Availability questions do not need a full run. Ask "is Nvidia's latest 10-K and Q3 call available?" and Kepler answers instantly through [`lookup_company`](/mcp/tools#lookup_company). It is a quick way to confirm coverage before kicking off longer research.
  </Accordion>

  <Accordion title="Expect runs to take a few minutes">
    Kepler reads primary sources rather than summarizing from memory, so a run takes a few minutes, and longer for big models. The wait is the work. Your assistant streams progress while it goes, so let it finish rather than restarting.
  </Accordion>

  <Accordion title="Keep the thread going">
    Follow-ups stay in the same conversation, so Kepler keeps full context from earlier runs. Add a column, break out a segment, or compare against a peer as a follow-up. Start a new conversation only when you switch topics.
  </Accordion>

  <Accordion title="Pick up earlier runs">
    You do not need to start over to revisit work. Ask for "the Netflix model from yesterday" and your assistant finds it with [`list_recent_runs`](/mcp/tools#list_recent_runs), then continues it.
  </Accordion>
</AccordionGroup>

## Trust and verify

<AccordionGroup>
  <Accordion title="Read the sourcing report">
    Every result includes a coverage summary that tells you whether each number is cited. When work has to be right, check it before you rely on an answer. See the [sourcing report](/mcp/tools#sourcing-report).
  </Accordion>

  <Accordion title="Trace a figure to its source">
    Citations are the point of Kepler. Open the link on any figure to see the exact filing or transcript it came from, and keep the links intact when you share or paste a result.
  </Accordion>

  <Accordion title="Export for downstream work">
    When you need the raw numbers, ask for a sheet as CSV and your assistant returns it through [`get_workbook_data`](/mcp/tools#get_workbook_data), or download the workbook as `.xlsx`. Every cell still traces back to a source.
  </Accordion>
</AccordionGroup>

<Card title="See it end to end" icon="lightbulb" href="/mcp/examples">
  Walk through full conversations that put these practices to work.
</Card>


# Connect a client
Source: https://docs.kepler.ai/mcp/connect

Add the Kepler connector to Claude, ChatGPT, Cursor, and other MCP clients.

Kepler is a remote MCP server. You add it to your client once using the connector URL, sign in with your Kepler account, and your assistant can run Kepler research from then on.

## Connector URL

Use this URL wherever your client asks for a remote MCP server or custom connector:

```text theme={null}
https://mcp.kepler.ai/api/mcp/v1
```

You can also find this URL inside the Kepler app under **Use through MCP** in the account menu, with a copy button and the setup steps.

<Frame>
  <img alt="Kepler app MCP connector page showing the connector URL and Claude setup steps" />
</Frame>

## Prerequisites

* A Kepler account with MCP access enabled. See [access](/mcp/overview#access) if your client reports access isn't enabled.
* An MCP-capable client (Claude, ChatGPT, Cursor, VS Code, or another that supports remote MCP servers).

## Set up your client

<Tabs>
  <Tab title="Claude">
    Works in Claude on the web and in the Claude desktop app.

    <Steps>
      <Step title="Open connector settings">
        Go to **Settings → Connectors** and choose **Add custom connector**.
      </Step>

      <Step title="Add the connector URL">
        Paste `https://mcp.kepler.ai/api/mcp/v1` and confirm.
      </Step>

      <Step title="Sign in to Kepler">
        When prompted, sign in with your Kepler account. Claude gets access through your own login, scoped to your conversations.
      </Step>

      <Step title="Start researching">
        Ask a financial question or request a model, for example *"Use Kepler to build a 3-statement model for Apple."* Runs take a few minutes and show live progress in the conversation.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude Code">
    Add Kepler as an HTTP transport MCP server from the CLI:

    ```bash theme={null}
    claude mcp add --transport http kepler https://mcp.kepler.ai/api/mcp/v1
    ```

    The first time a Kepler tool is used, Claude Code walks you through the OAuth sign-in in your browser. Run `claude mcp list` to confirm the server is connected.
  </Tab>

  <Tab title="ChatGPT">
    Custom connectors are available on ChatGPT plans that support them (Pro, Business, Enterprise, and Edu).

    <Steps>
      <Step title="Open connector settings">
        In **Settings → Connectors**, choose to add a custom connector.
      </Step>

      <Step title="Add the connector URL">
        Enter `https://mcp.kepler.ai/api/mcp/v1` as the MCP server URL and confirm.
      </Step>

      <Step title="Sign in to Kepler">
        Complete the OAuth sign-in with your Kepler account when prompted.
      </Step>

      <Step title="Use it in a conversation">
        Enable the Kepler connector for your chat, then ask a financial research question.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Cursor">
    Add Kepler to your MCP configuration file (`~/.cursor/mcp.json` for all projects, or `.cursor/mcp.json` in a project):

    ```json theme={null}
    {
      "mcpServers": {
        "kepler": {
          "url": "https://mcp.kepler.ai/api/mcp/v1"
        }
      }
    }
    ```

    Reload Cursor, then sign in to Kepler through the OAuth prompt when the server first connects. You can confirm the connection under **Settings → MCP**.
  </Tab>

  <Tab title="VS Code">
    Add Kepler to your MCP configuration (`.vscode/mcp.json` in a workspace, or your user `mcp.json`):

    ```json theme={null}
    {
      "servers": {
        "kepler": {
          "type": "http",
          "url": "https://mcp.kepler.ai/api/mcp/v1"
        }
      }
    }
    ```

    Start the server from the MCP view and complete the OAuth sign-in when prompted. Kepler's tools then become available to Copilot Chat in agent mode.
  </Tab>

  <Tab title="Other clients">
    Any client that supports remote MCP servers over streamable HTTP can connect to Kepler. Add `https://mcp.kepler.ai/api/mcp/v1` as a remote MCP server, and Kepler signs you in with standard OAuth 2.1. There are no API keys to manage, since authentication is handled through your Kepler login.
  </Tab>
</Tabs>

## Verify the connection

Once connected, ask your assistant a quick availability question that doesn't need a full run:

```text theme={null}
Use Kepler to check what filings are available for Microsoft.
```

This calls the [`lookup_company`](/mcp/tools#lookup_company) tool and returns instantly, a fast way to confirm the connector is working before kicking off a longer research run.

## Troubleshooting

<AccordionGroup>
  <Accordion title="My client says MCP access isn't enabled">
    MCP access is granted per account. If access isn't enabled after you sign in, ask your Kepler contact to enable it, then sign out of Kepler and back in so your session refreshes.
  </Accordion>

  <Accordion title="The OAuth sign-in didn't appear">
    Make sure you entered the full URL including the `/api/mcp` path. A bare domain won't resolve the connector. Remove and re-add the server to trigger the sign-in again.
  </Accordion>

  <Accordion title="A research run seems stuck">
    Runs are meant to take a few minutes, because Kepler is reading primary sources. Your assistant waits and streams progress. If a run runs long, it keeps waiting until a result or failure comes back. You can also continue the conversation or cancel the run. See [example workflows](/mcp/examples).
  </Accordion>
</AccordionGroup>


# Data handling and privacy
Source: https://docs.kepler.ai/mcp/data-handling

How the Kepler connector authenticates, what it accesses, and how your data is handled.

This page explains how the MCP connector handles access and data, so you and your security team know what to expect before connecting. The connector reaches Kepler the same way the app does and is held to the same protections.

## Authentication and access

* **You sign in as yourself.** The connector authenticates with OAuth 2.1 against your Kepler account. There are no API keys to create, paste, or rotate.
* **Scoped to you.** Your assistant can reach only your own conversations and results, the same data you would see in the app. You cannot see another user's research, and they cannot see yours.
* **Your sign-in token stays at the edge.** Your access token is validated when it reaches Kepler and is not passed along to the systems that run your research. Those systems act on your verified identity, not your credentials.
* **Access is read and run management only.** Through the connector, your assistant can start, continue, and cancel your own research runs and read your own results. It cannot change your account settings or anyone else's data.

## What is stored

Your research conversations and their results are saved to your Kepler account, just as they are when you use the app. That is what lets you revisit a run later, list recent runs, and continue a conversation with full context. A run you start through the connector appears in the [web app](https://app.kepler.ai), and the reverse holds too.

## What Kepler reads

To answer a request, Kepler reads public primary sources: SEC filings (XBRL), earnings call transcripts, and market data. It works from these documents directly, which is what makes every figure auditable through its citations.

## Transport

All communication with the connector is over HTTPS, so traffic between your client and Kepler is encrypted in transit.

## Compliance and trust

Kepler maintains a formal security program and is **SOC 2 Type II** certified, with **GDPR** and **CCPA** support, and **ISO 27001** in progress. For current details, certifications, and to request documentation, see the [Kepler security page](https://kepler.ai/security) and the [Trust Portal](https://trust.kepler.ai).

## Your data, retention, and deletion

How Kepler collects, retains, and deletes data, and your rights over it, are governed by Kepler's policies. Rather than restate them here, refer to the authoritative documents:

<CardGroup>
  <Card title="Privacy Policy" icon="shield-halved" href="https://kepler.ai/privacy">
    How Kepler handles personal data and your rights.
  </Card>

  <Card title="Terms" icon="file-contract" href="https://kepler.ai/terms">
    The terms governing your use of Kepler and your data.
  </Card>
</CardGroup>

## Questions

For security reviews, data processing questions, or vendor assessments, email [support@kepler.ai](mailto:support@kepler.ai) or see [Contact us](/contact).


# Example workflows
Source: https://docs.kepler.ai/mcp/examples

See the Kepler connector end to end in real conversations.

These examples show how a conversation flows once the connector is set up. You ask in natural language; your assistant calls the right Kepler [tools](/mcp/tools) and brings back cited results. The tool names below are shown only to make the mechanics clear. You never type them.

## Ask a research question

<Steps>
  <Step title="You ask">
    > Use Kepler to explain what drove Costco's gross margin over the last three fiscal years.
  </Step>

  <Step title="Kepler starts a run">
    Your assistant calls `run_financial_research` and gets back a `conversation_id`. It then calls `get_run_result` to wait, streaming progress as Kepler reads the 10-K filings.
  </Step>

  <Step title="You get a cited answer">
    A few minutes later the answer arrives, with each margin figure linked to the filing it came from and a sourcing report on coverage.
  </Step>

  <Step title="You follow up">
    > Now compare that to Walmart for the same period.

    Your assistant calls `continue_research` on the same conversation, and Kepler keeps full context and extends the analysis.
  </Step>
</Steps>

## Build a model and export it

<Steps>
  <Step title="You ask">
    > Use Kepler to build a 3-year annual income statement for Apple, each line cited to its 10-K.
  </Step>

  <Step title="Kepler returns a workbook">
    The result includes a workbook with a download link and an in-app link. Every cell traces back to a source.

    <Frame>
      <img alt="Apple income statement workbook built by Kepler, with sources and the answer summary" />
    </Frame>
  </Step>

  <Step title="You pull the data">
    > Give me the income statement sheet as CSV.

    Your assistant calls `get_workbook_data` and returns the full sheet as CSV for use in your own tools.
  </Step>
</Steps>

## Check coverage before a deep dive

Availability questions don't need a full run. They return instantly through `lookup_company`.

> Use Kepler to check whether Nvidia's latest 10-K and Q3 earnings call are available.

Your assistant lists the filings and transcripts Kepler has on file, with forms, dates, and fiscal periods, a quick way to confirm coverage before asking for analysis.

## Pick up an earlier run

> Find the Netflix model I built yesterday and add a fiscal 2025 column.

Your assistant calls `list_recent_runs` to locate the conversation, then `continue_research` to extend it, with no need to start over.

## Tips for better results

<AccordionGroup>
  <Accordion title="Name the company and the periods">
    "Apple's last three fiscal years" beats "Apple recently." Specific periods give Kepler a clear target and make citations easier to verify.
  </Accordion>

  <Accordion title="Say what structure you want">
    For models, describe the statement type, segments, and formatting up front, since it's faster than reshaping afterward.
  </Accordion>

  <Accordion title="Expect runs to take a few minutes">
    Kepler reads primary sources rather than summarizing from memory. The wait is the work; your assistant streams progress while it goes.
  </Accordion>

  <Accordion title="Keep the thread going">
    Follow-ups stay in the same conversation, so Kepler remembers prior results. Start a new request only when you switch topics.
  </Accordion>
</AccordionGroup>


# Kepler MCP connector
Source: https://docs.kepler.ai/mcp/overview

Bring citation-backed financial research into any MCP client.

The Kepler MCP connector lets AI assistants such as Claude, ChatGPT, and Cursor run Kepler research on your behalf. Ask a financial question or request a model from inside any conversation, and your assistant calls Kepler, returning the same citation-backed answers and spreadsheet workbooks you would get in the [Kepler app](https://app.kepler.ai), with every figure linked to its source.

[Model Context Protocol (MCP)](https://modelcontextprotocol.io) is an open standard for connecting AI assistants to external tools and data. Kepler runs a remote MCP server you add to your client once. After that, your assistant can reach Kepler's research tools whenever a conversation calls for them.

<Card title="Connect your client" icon="link" href="/mcp/connect">
  Add the connector to Claude, ChatGPT, Cursor, or any MCP client.
</Card>

## How it works

When you ask your assistant something like *"Use Kepler to build a 3-statement model for Apple,"* the assistant calls a Kepler tool over the connector. Kepler reads the primary sources, SEC filings (XBRL), earnings call transcripts, and market data, runs the research, and streams progress back into your conversation. The final answer arrives with inline citations, and any workbook is one click away.

Runs are asynchronous, so the connector splits the work across a few tools: one to **start** a run, one to **wait** for the result, and others to **continue**, **manage**, or **look up** data. Your assistant orchestrates them for you.

<Steps>
  <Step title="Start">
    Your assistant calls `run_financial_research` with your question. It returns a `conversation_id` right away and the run begins in the background.
  </Step>

  <Step title="Wait">
    Your assistant calls `get_run_result`, which holds the connection open and streams Kepler's progress while it reads sources. A run usually finishes in a few minutes.
  </Step>

  <Step title="Read">
    The result comes back with the answer, inline citations, a list of every source consulted, a sourcing report on coverage, and any workbooks Kepler produced.
  </Step>
</Steps>

See the [tools reference](/mcp/tools) for the full set and how your assistant chains them.

## What you get

<CardGroup>
  <Card title="Citation-backed answers" icon="quote-left">
    Every figure links to the filing or transcript it came from, with a sourcing report on coverage.
  </Card>

  <Card title="Spreadsheet workbooks" icon="table-cells">
    Model requests return downloadable `.xlsx` workbooks. Export any sheet as CSV for downstream analysis.
  </Card>

  <Card title="Live progress" icon="bars-progress">
    Long runs stream narration into your conversation, so you can see what Kepler is reading.
  </Card>

  <Card title="Your own data, your own login" icon="shield-check">
    The connector signs in as you over OAuth and is scoped to your own conversations. No API keys to manage.
  </Card>
</CardGroup>

## Connector details

|                    |                                                                           |
| ------------------ | ------------------------------------------------------------------------- |
| **Connector URL**  | `https://mcp.kepler.ai/api/mcp/v1`                                        |
| **Transport**      | Streamable HTTP (JSON-RPC 2.0)                                            |
| **Authentication** | OAuth 2.1. You sign in with your Kepler account.                          |
| **Capabilities**   | Tools and prompts. Supporting hosts also render an interactive run panel. |
| **Access**         | Enabled per account. See [access](#access) below.                         |

The connector implements the standard MCP handshake, so any compliant client negotiates the protocol version and discovers Kepler's tools and prompts automatically on connect. You do not configure tools by hand.

## Interactive run panel

In MCP hosts that support interactive panels, Kepler renders a live run view inline in your conversation: progress as Kepler reads sources, the finished answer with its citations, and any workbooks. Your assistant still writes the answer into the chat with its citation links intact, so the panel is a richer live view rather than a replacement for the text result. In clients without panel support, you get the same result as text and links.

## Security and access

* **You sign in as yourself.** The connector authenticates with OAuth 2.1 against your Kepler account. There are no API keys to create, paste, or rotate.
* **Scoped to your conversations.** Your assistant sees only your own runs and results, the same data you would see in the app.
* **Coverage matches the app.** Kepler covers publicly listed companies through their SEC filings and earnings call transcripts. The connector works with the same coverage as the Kepler app.

## Access

MCP access is rolled out per account. If your client reports that access is not enabled after you sign in, your Kepler contact may still need to turn it on for you. Once granted, sign out of Kepler and back in so your session picks up the change.

<Note>
  Kepler covers publicly listed companies through their SEC filings and earnings call transcripts. Check coverage for a specific company instantly with [`lookup_company`](/mcp/tools#lookup_company), no run required.
</Note>

## Next steps

<CardGroup>
  <Card title="Connect a client" icon="link" href="/mcp/connect">
    Step-by-step setup for Claude, ChatGPT, Cursor, and more.
  </Card>

  <Card title="Tools reference" icon="wrench" href="/mcp/tools">
    Every tool the connector exposes, with parameters and returns.
  </Card>

  <Card title="Prompts" icon="message-lines" href="/mcp/prompts">
    Ready-made starting points for models, recaps, and comparisons.
  </Card>

  <Card title="Example workflows" icon="lightbulb" href="/mcp/examples">
    Real conversations that show the connector end to end.
  </Card>
</CardGroup>


# Prompts
Source: https://docs.kepler.ai/mcp/prompts

Ready-made starting points for common research tasks.

The Kepler connector ships with a few **prompts**, pre-built starting points that some MCP clients surface as slash commands or quick actions. Pick one, fill in a company, and your assistant kicks off the right kind of run. You can always get the same results by asking in your own words. Prompts are just a faster on-ramp.

<Note>
  How prompts appear depends on your client. In clients that support MCP prompts, they show up as selectable commands. In others, you can describe the same request in natural language. Where a client supports argument autocomplete, the `company` field suggests matches from Kepler's coverage as you type.
</Note>

## Build a financial model

A citation-backed spreadsheet model for a company, an income statement, 3-statement model, comps, and more, built from SEC filings and market data.

| Argument  | Required | Description                                                                                                         |
| --------- | -------- | ------------------------------------------------------------------------------------------------------------------- |
| `company` | Yes      | Company name or ticker.                                                                                             |
| `details` | No       | What to build and how: statement type, periods, segments, formatting. Defaults to a 3-year annual income statement. |

## Recap an earnings call

A summary of a company's earnings call, results versus expectations, guidance, and notable management remarks, drawn from the transcript and the filed results.

| Argument  | Required | Description                                                               |
| --------- | -------- | ------------------------------------------------------------------------- |
| `company` | Yes      | Company name or ticker.                                                   |
| `period`  | No       | Fiscal period, for example `Q3 FY2026`. Defaults to the most recent call. |

## Compare companies

A side-by-side comparison of two or more companies on fundamentals, with every figure cited to its filing.

| Argument    | Required | Description                                                                                                                   |
| ----------- | -------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `companies` | Yes      | The companies to compare, for example `Netflix, Disney, Warner Bros. Discovery`.                                              |
| `focus`     | No       | What to compare on: metrics, periods, angle. Defaults to revenue growth, margins, and valuation over the last 3 fiscal years. |

## Next steps

<Card title="Example workflows" icon="lightbulb" href="/mcp/examples">
  See these prompts in action as full conversations.
</Card>


# Tools reference
Source: https://docs.kepler.ai/mcp/tools

Every tool the Kepler connector exposes to your assistant, with parameters and return shapes.

The connector exposes a set of tools that your assistant calls on your behalf. You don't call these directly. You ask in natural language, your assistant picks the right tools and chains them together, and you read the result. This page documents what each tool does, what it takes, and what it returns, so you understand what is happening and can guide your assistant when you want to.

Kepler runs are asynchronous, so the tools fall into four groups: **start** a run, **wait** for its result, **manage** existing runs, and **look up** reference data without a run.

## Tools at a glance

| Tool                                                | Group   | What it does                                           | Blocks? |
| --------------------------------------------------- | ------- | ------------------------------------------------------ | ------- |
| [`run_financial_research`](#run_financial_research) | Start   | Begin a new research run or model request              | No      |
| [`continue_research`](#continue_research)           | Start   | Send a follow-up into an existing conversation         | No      |
| [`get_run_result`](#get_run_result)                 | Wait    | Wait for a run and return its final result             | Yes     |
| [`continue_waiting`](#continue_waiting)             | Wait    | Resume waiting on a long run                           | Yes     |
| [`is_run_done`](#is_run_done)                       | Wait    | One-shot check of whether a run has finished           | No      |
| [`cancel_run`](#cancel_run)                         | Manage  | Stop a running conversation                            | No      |
| [`list_recent_runs`](#list_recent_runs)             | Manage  | List your recent conversations                         | No      |
| [`lookup_company`](#lookup_company)                 | Look up | Resolve a company and list its filings and transcripts | No      |
| [`get_workbook_data`](#get_workbook_data)           | Look up | Export a workbook sheet as CSV                         | No      |

## How your assistant chains the tools

Because a run continues in the background, starting one and reading its result are two separate steps. Your assistant orchestrates the loop for you:

```mermaid theme={null}
flowchart TD
  A[run_financial_research] --> B[get_run_result]
  B -->|status: completed| C[Cited answer and workbooks]
  B -->|status: running| D[continue_waiting]
  D -->|status: running| D
  D -->|status: completed| C
  B -->|status: failed| E[Failure reason]
```

A run usually finishes in a few minutes, though deeper models can take longer. The waiting tools hold the connection open and stream progress while Kepler reads sources, so you see narration in the conversation rather than a spinner.

## Start a run

### `run_financial_research`

Start a new Kepler run. This is the entry point for any research question or model request.

| Parameter | Type   | Required | Description                                                                                                                                   |
| --------- | ------ | -------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `request` | string | Yes      | The research question or artifact request in natural language. Include the company, the periods, and any structure or formatting preferences. |

Returns immediately with a `conversation_id` and a `status` of `running`. The run itself continues in the background. Your assistant then calls [`get_run_result`](#get_run_result) to wait for the answer.

```json theme={null}
{
  "conversation_id": "c_8f3a…",
  "status": "running",
  "next_step": "Call get_run_result with this conversation_id.",
  "conversation_link": "https://app.kepler.ai/c/8f3a…"
}
```

### `continue_research`

Send a follow-up into an existing conversation. Refine a model, ask about prior results, or extend the research. The agent keeps full context from the earlier run.

| Parameter         | Type   | Required | Description                                |
| ----------------- | ------ | -------- | ------------------------------------------ |
| `conversation_id` | string | Yes      | The conversation to continue.              |
| `message`         | string | Yes      | The follow-up request in natural language. |

Returns a conversation handle, the same shape as `run_financial_research`. Follow it with a wait.

## Wait for results

### `get_run_result`

Fetch a run's final result. It blocks while the run is still going and streams progress while it waits. Finished runs return immediately, so this is also how your assistant pulls the result of an earlier run. Your assistant calls this right after starting or continuing a run.

| Parameter         | Type   | Required | Description                  |
| ----------------- | ------ | -------- | ---------------------------- |
| `conversation_id` | string | Yes      | The conversation to wait on. |

A wait holds the connection open for a few minutes. A very long run can come back with `status: running` before it finishes. That is expected, and your assistant resumes with [`continue_waiting`](#continue_waiting). The returned object carries everything about the result:

| Field               | Type   | Description                                                                     |
| ------------------- | ------ | ------------------------------------------------------------------------------- |
| `status`            | string | `running`, `completed`, `failed`, or `access_denied`.                           |
| `answer`            | string | The final answer text, with inline citation links, when completed.              |
| `failure`           | string | The reason, when status is `failed`.                                            |
| `recent_progress`   | array  | The latest narration updates from the run.                                      |
| `citations`         | array  | The sources cited in the answer (see [citation shape](#citations-and-sources)). |
| `all_sources`       | array  | Everything Kepler consulted, cited or not, newest period first.                 |
| `workbooks`         | array  | Any workbooks the run produced (see [workbook shape](#workbooks)).              |
| `sourcing`          | object | A citation-coverage report (see [sourcing report](#sourcing-report)).           |
| `conversation_link` | string | A deep link to the conversation in the Kepler app.                              |

### `continue_waiting`

Resume waiting after `get_run_result` returned `running`. Identical blocking behavior, used for follow-up waits on long runs. Your assistant calls it in a loop until the run completes or fails.

| Parameter         | Type   | Required | Description                          |
| ----------------- | ------ | -------- | ------------------------------------ |
| `conversation_id` | string | Yes      | The conversation to keep waiting on. |

Returns the same shape as `get_run_result`.

### `is_run_done`

A one-shot, non-blocking check of whether a run has finished. Returns right away. This is a status check, not a polling loop. To actually get the result, blocking on a running run or fetching a finished one, use `get_run_result`.

| Parameter         | Type   | Required | Description                |
| ----------------- | ------ | -------- | -------------------------- |
| `conversation_id` | string | Yes      | The conversation to check. |

Returns `done` (boolean) and the current `status`.

## Manage runs

### `cancel_run`

Stop a running conversation, for example when you changed your mind, mistyped a ticker, or started a duplicate. Non-destructive: the conversation and any partial results survive, and `continue_research` can re-engage it with full context. No effect on finished runs.

| Parameter         | Type   | Required | Description                       |
| ----------------- | ------ | -------- | --------------------------------- |
| `conversation_id` | string | Yes      | The running conversation to stop. |

Returns the `conversation_id` and a `status` of `cancelling`.

### `list_recent_runs`

List your most recent Kepler conversations. Useful for finding an earlier run, such as "the Netflix model from yesterday," to continue or fetch results from.

| Parameter | Type    | Required | Description                                                             |
| --------- | ------- | -------- | ----------------------------------------------------------------------- |
| `limit`   | integer | No       | Maximum conversations to return. Default `10`, clamped to 1 through 25. |

Returns a list of `runs`, newest first, each with a `conversation_id`, `title`, created and updated timestamps, and a `conversation_link`.

## Look up reference data

### `lookup_company`

Resolve a company and list the SEC filings and earnings-call transcripts Kepler has on file. Instant, with no run required. It answers questions like "is the Q3 call available?", "when did they last file a 10-K?", or "does Kepler cover this company?". It returns metadata only. For the contents of a filing, the numbers, quotes, or analysis, run a research request instead.

| Parameter    | Type    | Required | Description                                                                          |
| ------------ | ------- | -------- | ------------------------------------------------------------------------------------ |
| `company`    | string  | Yes      | Company name, ticker symbol, or SEC CIK.                                             |
| `form_types` | string  | No       | Comma-separated SEC form filter, for example `"10-K,10-Q"`.                          |
| `limit`      | integer | No       | Maximum filings and transcripts to list. Default `10`, clamped to 1 through 50 each. |

Returns:

| Field           | Type   | Description                                                                                                               |
| --------------- | ------ | ------------------------------------------------------------------------------------------------------------------------- |
| `status`        | string | `ok` or `no_match`.                                                                                                       |
| `company`       | object | The resolved match: `cik`, `name`, `ticker`, `total_filings`, `last_filing_date`.                                         |
| `other_matches` | array  | Alternative matches when the query is ambiguous, each with `cik`, `name`, `ticker`.                                       |
| `filings`       | array  | Available filings, each with `form_type`, `filed_date`, `period_end_date`, and `fiscal_period` (for example `Q1 FY2026`). |
| `transcripts`   | array  | Available earnings-call transcripts, each with `title`, `fiscal_period`, and `event_date`.                                |

### `get_workbook_data`

Get the full cell data of one workbook sheet as CSV (RFC 4180), for downstream analysis beyond the tables shown in a result. Omit `sheet_name` to list a multi-sheet workbook's sheets first.

| Parameter     | Type   | Required | Description                                                                       |
| ------------- | ------ | -------- | --------------------------------------------------------------------------------- |
| `workbook_id` | string | Yes      | Workbook id from a run result.                                                    |
| `sheet_name`  | string | No       | Sheet to export, case-insensitive. Optional when the workbook has a single sheet. |

Returns the sheet as CSV text, alongside the `workbook_id`, the workbook `name`, and the list of available `sheets`.

## Result shapes

The result-bearing tools share a few nested structures. Knowing the field names helps you read what your assistant brings back, and ask it for more.

### Citations and sources

Each entry in `citations` and `all_sources` describes one source:

| Field   | Type    | Description                                                                                              |
| ------- | ------- | -------------------------------------------------------------------------------------------------------- |
| `n`     | integer | The citation number, matching the inline marker in the answer (`citations` only).                        |
| `label` | string  | A human-readable source label, for example `Apple 10-K (FY2024)`.                                        |
| `url`   | string  | A link to the source, when one is available.                                                             |
| `kind`  | string  | The source type: `filing`, `transcript`, `market-data`, `presentation`, `news`, `web`, and a few others. |

`citations` are the sources actually referenced in the answer. `all_sources` is everything Kepler consulted, whether cited or not, ordered newest period first.

### Workbooks

Each workbook in a result includes:

| Field          | Type   | Description                                                  |
| -------------- | ------ | ------------------------------------------------------------ |
| `workbook_id`  | string | The id to pass to [`get_workbook_data`](#get_workbook_data). |
| `name`         | string | The workbook title.                                          |
| `sheets`       | array  | The sheet names in the workbook.                             |
| `link`         | string | A link to open the workbook in the Kepler app.               |
| `download_url` | string | A link to download the workbook as `.xlsx`.                  |

### Sourcing report

The `sourcing` object summarizes how much of the answer is backed by citations:

| Field             | Type    | Description                                          |
| ----------------- | ------- | ---------------------------------------------------- |
| `cited_count`     | integer | The number of distinct figures cited.                |
| `uncited_figures` | integer | The count of numbers in the answer with no citation. |
| `fully_cited`     | boolean | Whether every number in the answer is cited.         |

Lead with this when work has to be right: it tells you, at a glance, whether an answer is fully sourced before you rely on it.

<Note>
  Tool names, parameters, and behavior are set by the connector and may evolve. Your assistant always sees the current definitions when it connects, so you don't need to track changes yourself. For the canonical list, point your client at the connector and read its advertised tools.
</Note>


# Quickstart
Source: https://docs.kepler.ai/quickstart

From zero to your first citation-backed answer.

This guide takes you from signing in to reading your first sourced result. You can use Kepler in two ways: directly in the web app, or through the [MCP connector](/mcp/overview) inside an AI assistant like Claude. This quickstart uses the web app.

## Prerequisites

* A Kepler account. If you don't have one, reach out to your Kepler contact for access.
* A company you want to research: a name (`Netflix`), a ticker (`NFLX`), or an SEC CIK.

## Run your first research

<Steps>
  <Step title="Sign in">
    Open [app.kepler.ai](https://app.kepler.ai) and sign in with your Kepler account.
  </Step>

  <Step title="Ask a question">
    In the chat, ask a financial research question in plain language. Be specific about the company and the periods you care about.

    ```text theme={null}
    What drove the change in Costco's gross margin over the last three fiscal years?
    ```
  </Step>

  <Step title="Let Kepler work">
    Kepler finds the relevant filings and transcripts, extracts the figures, and writes an answer. A run typically takes a few minutes, and you'll see live progress as it reads sources and builds results.

    <Frame>
      <img alt="Kepler showing live progress and the SEC filings it is reading" />
    </Frame>
  </Step>

  <Step title="Read the answer and check the sources">
    Every figure in the answer links back to the filing or transcript it came from. Open a citation to see the original source, and review the sourcing report to confirm coverage.

    <Frame>
      <img alt="A workbook cell selected, with the matching value highlighted in Apple's 10-K alongside it" />
    </Frame>
  </Step>
</Steps>

## Ask for a model

Kepler can return a spreadsheet workbook, not just prose. Try:

```text theme={null}
Build a 3-year annual income statement for Apple, with each line cited to its 10-K.
```

The result includes a workbook you can open in the app or download as `.xlsx`. Every cell traces back to a source.

## Next steps

<CardGroup>
  <Card title="Use Kepler in your assistant" icon="plug" href="/mcp/overview">
    Bring Kepler into Claude, ChatGPT, or Cursor with the MCP connector.
  </Card>

  <Card title="Connect a client" icon="link" href="/mcp/connect">
    Step-by-step setup for each MCP client.
  </Card>
</CardGroup>

<Tip>
  Need help or access? Reach out to your Kepler contact, or email [support@kepler.ai](mailto:support@kepler.ai).
</Tip>


# Release notes
Source: https://docs.kepler.ai/release-notes

What's new in Kepler, newest first.

<Update label="Week of July 27">
  ## <Icon icon="arrow-trend-up" /> Analyst ratings and estimates

  Consensus ratings, price target ranges, and quarterly results measured against street estimates, on every company page and in chat. Drill into the covering firms and each analyst's track record.

  ## <Icon icon="microphone-lines" /> Extended transcripts covering all company events

  Research across investor days, capital markets days, conference presentations, and M\&A calls with the same transcript coverage as earnings calls, every quote cited to the event it came from.
</Update>

<Update label="Week of July 20">
  ## <Icon icon="magnifying-glass" /> Search inside your documents

  Library search reads the full text of every file, so a phrase, a name, or a number finds the document it lives in, whatever the file is called.

  ## <Icon icon="scroll" /> Polished document reader

  PDFs and decks open full width and scroll continuously from cover to close. Zoom stays sharp at any size, and clicking a citation drops you on the exact page with the source highlighted.
</Update>

<Update label="Week of July 13">
  ## <Icon icon="share-nodes" /> Share a chat with anyone

  Send someone a link and they read the whole chat, citations and workbooks included, without a Kepler account. They click through to your sources exactly as you would. Monitor who opens your link and revoke access whenever.

  ## <Icon icon="table-columns" /> Annual and quarterly reports, split out

  Financials separate into annual and quarterly views, so you pull the period you need without hunting for it.

  ## <Icon icon="bullseye" /> Citations reach the footnotes

  Numbers buried in a filing's footnotes and exhibits carry the same click-through citation as the face of the statements.
</Update>

<Update label="Week of July 6">
  ## <Icon icon="chart-simple" /> Key Metrics

  Fully diluted shares, market cap, and enterprise value on every company page, computed in code from the filings, never written by a model. Value a name point in time, on weighted-average shares, or at a deal price.

  ## <Icon icon="folder-tree" /> Document browser

  Browse and manage everything in your workspace as a folder tree, with search and paging across your files. Review documents you have emailed, uploaded, or have access to through your SharePoint. Start a new chat from any one or multiple documents.
</Update>

<Update label="Week of June 29">
  ## <Icon icon="envelope" /> Forward email into Kepler

  Forward an email to your Kepler inbox and research across it like any other document, citations included. Send any email and attachment to [jo@kepler.ai](mailto:jo@kepler.ai) to get started.

  ## <Icon icon="paperclip" /> 8-K exhibits in the viewer

  Open the exhibits attached to an 8-K directly in the filing viewer.
</Update>

<Update label="Week of June 22">
  ## <Icon icon="code-branch" /> Model routing and failover

  Every question routes to the right model tier on its own, and if a provider goes down Kepler fails over to a backup so your work keeps moving. You can also set the tier yourself from the chat input.

  ## <Icon icon="file-lines" /> Word documents

  Upload .docx files, read them in-app, and cite them the same way you would a filing.

  ## <Icon icon="signal" /> Status page

  A live status page for the platform, so you can check availability at a glance.

  ## <Icon icon="compass" /> Guided onboarding

  New users get a guided walkthrough, from first question to cited answer.
</Update>

<Update label="Week of June 15">
  ## <Icon icon="plug" /> SharePoint connector (Alpha)

  Connect your firm's SharePoint, choose the sites and folders Kepler can see, and research across your own documents with citations that land on the exact page.

  ## <Icon icon="globe" /> Choose your web sources

  Tell the agent which websites to search, so answers draw only on the sources your team trusts.
</Update>

<Update label="Week of June 8">
  ## <Icon icon="calculator" /> Capitalization workflows

  Run fully diluted shares, equity value, enterprise value, or capital structure as a workflow, computed as of any date you name and traced field by field to the filings.

  ## <Icon icon="paperclip" /> Exhibits, read end to end

  Kepler reads the attachments and exhibits filed alongside a document, so material contracts and schedules land in the answer.

  ## <Icon icon="file-arrow-up" /> Excel files in your library

  Upload workbooks to your library and pull them into a chat.

  ## <Icon icon="building" /> Company pages, restyled

  Filings grouped by category with a cleaner sidebar, so the document you want is a click away.
</Update>

<Update label="Week of June 1">
  ## <Icon icon="magnifying-glass" /> Search your conversations

  Find any past chat in a keystroke from the sidebar.

  ## <Icon icon="puzzle-piece" /> Personalized skills

  Tailor Kepler's analysis skills to your own methodology, so each workflow runs the way your team does it, every time.

  ## <Icon icon="book-open" /> Read an entire filing, start to finish

  Ask for a full read and Kepler works through the whole filing in one pass, so nothing gets missed.

  ## <Icon icon="copy" /> Copy or export any filing table

  Lift a whole table out of a filing in one click, straight to your clipboard or to Excel.
</Update>

<Update label="Week of May 25">
  ## <Icon icon="chart-line" /> Valuation and trading comps

  Enterprise value, equity value, EV/EBITDA, P/E, fully diluted shares, and capital structure, each computed in code and linked to the filing it draws from.

  ## <Icon icon="flask" /> Bring your own model (Alpha)

  Upload an Excel workbook and ask questions against it next to Kepler's data, with every figure tied back to where it came from.
</Update>

<Update label="Week of May 18">
  ## <Icon icon="scale-balanced" /> Compare companies side by side

  Line up a peer set and compare the metrics that matter, every figure on the table linked to the filing it came from.

  ## <Icon icon="table" /> Inline data tables

  Results come back as clean tables you can scan at a glance and copy straight into your own model.
</Update>

<Update label="Week of May 11">
  ## <Icon icon="file-import" /> Bring your own documents (Alpha)

  Add your own PDFs, memos, and notes to a session and research across them exactly as you would a filing.

  ## <Icon icon="folder" /> Projects

  Group your research, sheets, and sources into projects, so a coverage name or live deal stays together in one place.
</Update>

<Update label="Week of May 4">
  ## <Icon icon="newspaper" /> News and press releases in every profile

  Company profiles carry the latest news and press releases, each headline linked to its source.
</Update>

<Update label="Week of April 27">
  ## <Icon icon="file-export" /> Export to Excel

  Pull any dataset out of a filing and download it as a clean Excel workbook, with formulas and structure intact.
</Update>

<Update label="Week of April 20">
  ## <Icon icon="table-cells" /> Build financial models in chat (Alpha)

  Ask for a model and watch the workbook build cell by cell. Every formula is visible and every number traces to the figure it came from, so the math is yours to verify. Prices are split-adjusted and cited.

  ## <Icon icon="id-card" /> Company profiles

  Every company has a profile that pulls its stock chart, filings, earnings transcripts, investor decks, and news into one place, showing only the data available for that name.
</Update>

<Update label="Week of April 13">
  ## <Icon icon="file-contract" /> Every major US filing, fully covered

  Research across 10-Ks, 10-Qs, 8-Ks, proxy statements, IPO prospectuses (S-1), and international filings (20-F), with earnings call transcripts alongside them. Open any filing and jump straight to the section you need.

  ## <Icon icon="book-open-reader" /> Read filings in-app

  Filings render in a built-in viewer with zoom, full-width tables, and embedded exhibits intact. No download needed, no tab-switching.

  ## <Icon icon="link" /> Click any number, see its source

  Every figure in an answer traces to the exact line of the filing behind it, in prose, in tables, and across company comparisons. The work shows itself.
</Update>


# Single sign-on
Source: https://docs.kepler.ai/sso

Sign in to Kepler with your identity provider, and set up SSO for your organization.

Kepler supports single sign-on (SSO) so your team can access Kepler with the identity provider you already use. SSO centralizes access in your IdP, so you manage who can reach Kepler from one place and users sign in without a separate password.

## Ways to sign in

Individual users can sign in to [app.kepler.ai](https://app.kepler.ai) with any of these:

* Email and password
* Magic link sent to your email
* Google
* Microsoft
* Enterprise SSO, when your organization has it configured

The connector uses the same sign-in. When you add the [MCP connector](/mcp/overview) to an assistant, you authenticate with your Kepler account, so your organization's SSO applies there too.

## How sign-in works

Kepler hands authentication to a dedicated, secure sign-in service rather than handling your credentials itself. The flow is the same standard redirect you see across modern apps:

<Steps>
  <Step title="Start sign-in">
    You open [app.kepler.ai](https://app.kepler.ai) and choose to sign in. Kepler sends you to its hosted sign-in page.
  </Step>

  <Step title="Verify who you are">
    You authenticate with your chosen method: email and password, a magic link, Google, Microsoft, or your organization's SSO. For enterprise SSO, the sign-in page hands off to your identity provider, which verifies you and sends you back.
  </Step>

  <Step title="Return with a verified identity">
    On success, you are redirected back to Kepler with a verified identity. Kepler establishes your session, and you never share your password with Kepler's application directly.
  </Step>
</Steps>

The [MCP connector](/mcp/overview) follows the same flow over OAuth 2.1. The first time your assistant uses Kepler, it opens this sign-in in your browser. You authenticate exactly as above, and the assistant receives a token scoped to your account, no password and no API key. Your sign-in token is validated when it reaches Kepler and is not passed to the systems that run your research. See [data handling and privacy](/mcp/data-handling).

## Enterprise SSO

Kepler supports enterprise SSO over **SAML 2.0** and **OIDC**, which covers the major identity providers, including Microsoft Entra ID, Okta, and Google Workspace. Your IdP becomes the source of truth for who can sign in to Kepler.

### Set up SSO for your organization

SSO is configured per organization. To enable it, contact your Kepler contact or email [support@kepler.ai](mailto:support@kepler.ai). Setup is a short exchange:

<Steps>
  <Step title="Tell us your provider">
    Let Kepler know which identity provider you use and that you want to connect over SAML or OIDC.
  </Step>

  <Step title="Exchange connection details">
    You provide your IdP metadata, and Kepler provides the values your IdP needs, such as the sign-in URL and the redirect target. The exact fields depend on your provider.
  </Step>

  <Step title="Map users and roles">
    Choose which users or groups in your IdP get access. Kepler organizes access by organization, with roles that control what each member can do.
  </Step>

  <Step title="Test and roll out">
    Verify a test sign-in, then roll SSO out to your team. After that, users sign in to Kepler through your provider.
  </Step>
</Steps>

<Note>
  SSO setup is handled with the Kepler team rather than a self-serve settings page. Reach out and we will walk you through it for your provider.
</Note>

## Organizations and roles

Kepler accounts belong to an organization. Within an organization, members hold roles that govern access, and organization admins manage membership from the Kepler app. SSO ties this to your IdP, so adding or removing someone there controls their access to Kepler.

## Need help?

For SSO setup, provisioning, or access questions, contact your Kepler contact or email [support@kepler.ai](mailto:support@kepler.ai). See [Contact us](/contact) for all channels.