Welcome

Welcome to our interactive API documentation platform! It's built to make it easier for you to explore endpoints, test requests instantly, and integrate faster into your applications.

Beyond browsing and testing endpoints in your browser, you now have two additional ways to build with Saner: a production-ready Python SDK for writing integration code, and an MCP server that gives AI-powered editors like Cursor, Windsurf, and Claude Code read-only access to Saner's API and SDK documentation.

This guide will help you get familiar with the new interface and show you how to make the most of all three.

What the Interactive Docs Offer

With this platform, you can:

• Make live API requests directly from your browser
• Switch between multiple programming language examples
• Save and reuse your API credentials
• View real-time request and response data
• Quickly search endpoints and workflows
• Copy ready-to-use SDK code snippets

These improvements are designed to reduce setup time and simplify your integration experience.

Three Ways to Integrate with Saner

You don't have to pick just one. Many teams explore an endpoint here first, generate a working example through the MCP server, then drop the finished code into a script built with the SDK.

---

Build with Code: The Saner Python SDK

The Saner Python SDK provides a production-ready interface for integrating with the Saner Platform APIs quickly and reliably. Instead of manually constructing and managing raw HTTP requests, developers can interact with Saner services using structured Python methods aligned directly with platform endpoints.

Why Use the SDK Instead of Raw API Calls?

Working directly against the raw API means you're responsible for handling validation, retries, timeouts, and auth plumbing yourself. The SDK takes care of this automatically, so you can focus on your integration logic:

• Strict parameter validation before a request is ever sent, preventing invalid calls that would otherwise fail at the server
• Built-in retry with exponential backoff, so transient network or server issues don't require you to write your own retry logic
• Configurable request timeouts, instead of managing them manually per request
• Multi-account support in a single script, without re-implementing auth handling for each account
• Integrated logging for debugging and traceability out of the box
• Rich IDE docstrings, so parameters and usage guidance show up inline as you type
• Consistent, predictable structure that stays aligned with the API documentation, so what you read here matches what you call in code

In short, the SDK removes the boilerplate and error-handling burden of raw API calls, letting you write less code to do the same integration work, more reliably.

Typical Use Cases

• Automating vulnerability and posture workflows
• Managing organizations, users, and assets programmatically
• Integrating Saner into CI/CD security pipelines
• Building multi-account orchestration scripts
• Creating security monitoring and reporting automation

---

Accelerate Development: Saner MCP Server

What is MCP?

The Saner Model Context Protocol (MCP) server gives AI-powered development tools direct access to the Saner API and Python SDK documentation. This enables developers to explore endpoints, generate SDK examples, and build integrations faster using natural-language prompts inside their editor.

The server is read-only. It serves API specifications and SDK documentation so your assistant can help you build integrations. It does not call the Saner API, does not hold your credentials, and cannot reach your Saner account.

Model Context Protocol (MCP) is an open standard that allows AI applications to securely access external tools, APIs, and documentation sources. By connecting your AI assistant to the Saner MCP server, the assistant gains contextual awareness of Saner APIs and can help generate accurate integration workflows in real time.

What MCP Enables

Once connected, MCP gives your AI assistant structured access to the Saner API documentation directly inside your development environment. This allows you to:

• Discover Saner APIs without manually browsing documentation
• Search endpoint usage from within your editor
• Generate ready-to-use Python SDK examples
• Understand parameters and request structures instantly
• Explore the APIs covering organizations, agents, vulnerabilities, compliance data, and reports
• Build automation scripts using Saner APIs faster

Instead of switching between documentation and code, developers can interact with Saner APIs conversationally through their AI assistant.

Key Capabilities

Direct API awareness inside your editor: your AI assistant understands available Saner endpoints and how they map to SDK resources and workflows.

"Show me how to get organization details in Saner"

Documentation search from the assistant: search Saner documentation without leaving your coding environment.

"What parameters are required for agent download in Saner?"

Integration code generation: generate working integration snippets instantly using supported SDK patterns.

"Generate Python SDK code to export a vulnerability report in Saner"

Endpoint discovery assistance: explore related APIs automatically.

"Show APIs related to compliance management in Saner"

What the Server Does and Does Not Do

Because the server never contacts Saner, anything your assistant reports about your environment comes from a script you ran yourself, not from the MCP server. Scripts your AI assistant writes run against your live Saner tenant, and endpoints that create, update, delete, scan, or remediate make real changes, so review generated code before running it, and test against a non-production account first where you can.

Supported AI Development Tools

The Saner MCP server works with any MCP-compatible AI client, including:

• Claude Code
• Cursor
• Windsurf
• Claude Desktop
• Other MCP-compatible development assistants

Once configured, these tools can access Saner documentation and API capabilities directly through the MCP server.

Why Use MCP with Saner?

Using MCP significantly improves developer productivity by allowing AI assistants to understand Saner APIs automatically, generate correct SDK usage patterns, reduce documentation lookup time, accelerate automation development, and simplify integration workflows overall, resulting in faster, more reliable interaction with the Saner platform directly from your editor.

---

What You'll Learn in This Guide

This guide walks you through how to:

1. Make your first API call using the Try It feature
2. Select your preferred programming language
3. Locate SDK code snippets for your application
4. Understand request and response sections
5. Navigate documentation efficiently
6. Get started with the Python SDK for production integrations
7. Connect an AI assistant to the Saner MCP server for editor-native API discovery and code generation

By the end of this guide, you'll be able to confidently explore and test APIs directly within the documentation, integrate them into production code with the SDK, and accelerate development further with MCP.

Before You Begin

Make sure you have:

• Your API credentials (such as an API key or access token)
• Your Account ID

If you don't have credentials yet, please contact your administrator.

Next Steps

• Try it now: Make your first live API call using the Try It feature in these docs
• Go deeper with code: See Installation and Request and Response Structure to start using the Python SDK
• Bring AI into your workflow: See Connect to Saner MCP Server to set up MCP in Cursor, Windsurf, or Claude Desktop

Let's get started by making your first API call inside the documentation.