# Partner or OEM

> Ten minutes: get Keryn's results as standard files your product can read (SARIF 2.1.0, CycloneDX 1.6, result JSON), then run a free trust scan on Keryn Cloud through its API.

Source: https://keryn.dev/docs/start/partner/

**You get:** Keryn's results as standard files your product already reads, the code to consume them, and a first call to the Keryn Cloud API. **You need:** a current browser; for step 3, a GitHub or Google account to sign in to Keryn Cloud.

The SDK and thin MCP client are available on npm. See [Download](https://keryn.dev/download/) for current CLI channel status. The browser workflow exports the sample reports. The shell examples show how to generate and read them locally.

## 1. Results as standard files (3 minutes)

Download [helpdesk.zip](https://keryn.dev/samples/helpdesk.zip), open [keryn.app](https://keryn.app), choose **File** under **Scan** and drop the zip. When the scan finishes, open **Findings** and choose **Share and export**:

![The Share and export menu of Keryn Web after the helpdesk.zip scan: SARIF 2.1.0, Result JSON, the evidence bundle, Problems for VS Code and the CycloneDX 1.6 AI-BOM, generated in the tab.](https://keryn.dev/screens/role-partner-export-1280-light.webp)

*Share and export: SARIF 2.1.0, result JSON, the evidence bundle, VS Code problems and the CycloneDX 1.6 AI-BOM, generated in the tab. Taken from keryn.app main-5g3Rr4q1.js.*

Every file is generated in your tab. **SARIF 2.1.0** is what code-scanning products read; **CycloneDX 1.6 AI-BOM** is the AI inventory; **Result JSON** is Keryn's full result, with its schema in the [schemas reference](https://keryn.dev/docs/reference/schemas/).

**The sample's code**

These are the files in `helpdesk.zip`, from the [AppSec journey](https://keryn.dev/docs/journeys/appsec/).

```python
import subprocess
import urllib.request

def run_command(command: str) -> str:
    """Run a shell command for the agent and return what it printed."""
    done = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=30)
    return done.stdout

def fetch_page(url: str) -> str:
    """Download a page so the agent can read it."""
    with urllib.request.urlopen(url, timeout=10) as resp:
        return resp.read().decode("utf-8", "replace")
```

```python
import os

from anthropic import Anthropic

from helpdesk.tools import run_command

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

SYSTEM = "You are a help desk agent. Reply with one shell command that diagnoses the ticket."

def handle_ticket(ticket_text: str) -> str:
    reply = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=200,
        system=SYSTEM,
        messages=[{"role": "user", "content": ticket_text}],
    )
    command = reply.content[0].text
    return run_command(command)
```

```text
anthropic==0.40.0
```

## 2. Read them in your product (3 minutes)

Each finding has a stable fingerprint, so you can deduplicate across rescans. These commands read the same formats; the page's tests run them on files the pre-release CLI writes for the sample, which are the formats Keryn Web exports:

```sh
keryn scan . -q --sarif keryn.sarif --aibom aibom.cdx.json
```

```sh
jq -r '.runs[0].results[] | [.level, .ruleId, (.partialFingerprints | keys[0])] | @tsv' keryn.sarif | sort | uniq -c | sort -rn | head -5
```

```text
      2 note	keryn.inv.lib.anthropic	keryn/fingerprint/v1
      1 warning	seceng/http_fetch_url	keryn/fingerprint/v1
      1 warning	seceng.llm05.python-subprocess-shell-true	keryn/fingerprint/v1
      1 warning	keryn.general.python.urlopen-any-scheme	keryn/fingerprint/v1
      1 warning	keryn.general.python.subprocess-shell-dynamic-command	keryn/fingerprint/v1
```

```sh
jq -r '.components[] | "\(.type) \(.name)"' aibom.cdx.json | sort -u
```

```text
library anthropic
machine-learning-model claude-sonnet-4-5
```

## 3. A trust scan on Keryn Cloud (4 minutes)

Keryn Cloud runs scans for you on Keryn's servers. A trust scan of a website reads its public trust pages (security, privacy, sub-processors) and draws no credit.

1. Open [api.keryn.app/account](https://api.keryn.app/account) and sign in with **GitHub** or **Google** under **Other ways to sign in** (no email is sent; an email link is also offered). Choose **Create organization**.
2. In [keryn.app](https://keryn.app), open **Cloud**, choose **Sign in** and approve the code in your account tab.
3. Choose **New scan**, **Trust site**, and enter a site you are allowed to test. The report is stored in your organization.

The same scan through the API, with an API key from **Developers**, **API keys** on the account page (creating one asks for an authenticator code, so set one up under **Security** first). This needs your own account, so this page's tests do not run it:

```text
POST https://api.keryn.app/api/v1/cloud-scans
Authorization: Bearer keryn_…
Content-Type: application/json

{"kind": "trust", "target": "https://your-site.example"}
```

The answer is the stored scan with its findings; `GET /api/v1/cloud-scans/{id}` returns the full report. Every route is in the [Cloud API reference](https://keryn.dev/docs/reference/api/). Hosted analysis that spends credit, `POST /api/v1/scans`, costs 1 cent per page from your starter credit.

## Next

- [Partner tracks](https://keryn.dev/partners/) and [deployment models](https://keryn.dev/partners/deployment-models/): embedding, white label and on-premises.
- [Become a partner](https://keryn.dev/partners/apply/): a person at Keryn reads each request.
