Integrate GAMP in minutes

Quickstart

Four steps from zero to a live trust badge on your site.

1. Create an Account

Your GAMP account is your identity in the registry. Every model you register is tied to this account. When you apply for an audited tier, GAMP reviewers use your account profile to verify your identity and contact you.

Required profile fields

2. Register Your Model

Registration creates a cryptographically signed passport for your AI model. The passport contains the information you provide, hashed and signed with GAMP's master Ed25519 key, then stored in the public registry.

Registration fields

3. Your Private Key

At registration, GAMP generates an Ed25519 keypair for your model. The private key is returned once in the registration response and never stored by GAMP. The public key is stored in the registry and used to verify your model's signed outputs.

Where to store it

export GAMP_PRIVATE_KEY="-----BEGIN PRIVATE KEY-----
MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQg...
-----END PRIVATE KEY-----"

GAMP_MODEL_ID=mdl_abc123
GAMP_PRIVATE_KEY=-----BEGIN PRIVATE KEY-----\nMIGH...\n-----END PRIVATE KEY-----

4. Embed the Badge

The live badge reflects your model's current trust status in real time. When your tier changes or your trust score updates, every embedded badge updates automatically — no code change required on your site.

<!-- GAMP Trust Badge -->
<script
  src="https://gampid.co.za/badge.js"
  data-gamp-model-id="mdl_YOUR_MODEL_ID"
  data-theme="light"
  data-size="medium"
></script>

[![GAMP Verified](https://gampid.co.za/models/mdl_YOUR_MODEL_ID/badge.svg)](https://gampid.co.za/transparency/passport/mdl_YOUR_MODEL_ID)

Badge states

Python SDK

The Python SDK is a single file with no external dependencies beyond the cryptography package. Copy gamp_sdk.py from the registry or install it directly.

pip install cryptography
# Then copy gamp_sdk.py into your project
# or download from: https://gampid.co.za/sdk/gamp_sdk.py

Signing Outputs

Wrap your model in the GAMPAgent class to sign every output with your Ed25519 private key. Signed outputs can be independently verified by anyone using only your public GAMP passport — no API key required.

from gamp_sdk import GAMPAgent
import os

agent = GAMPAgent(
    model_id=os.environ["GAMP_MODEL_ID"],
    private_key_pem=os.environ["GAMP_PRIVATE_KEY"],
)

# Sign a single output
response = "The capital of France is Paris."
signed = agent.sign_output(response)

print(signed.output_text)   # The capital of France is Paris.
print(signed.signature)     # Base64 Ed25519 signature
print(signed.output_hash)   # SHA-256 of the output

# Use as a decorator
from gamp_sdk import gamp_signed

@gamp_signed(agent)
def my_model(prompt: str) -> str:
    return llm.generate(prompt)

result = my_model("What is 2+2?")
# result is a SignedOutput with .output_text and .signature

const { GAMPAgent } = require('./gamp_sdk.js');

const agent = new GAMPAgent({
  modelId: process.env.GAMP_MODEL_ID,
  privateKeyPem: process.env.GAMP_PRIVATE_KEY,
});

// Express middleware — signs every response automatically
app.use(agent.expressMiddleware());

// Or sign manually
const signed = await agent.signOutput("The capital of France is Paris.");
console.log(signed.outputText);
console.log(signed.signature);

Verifying Outputs

Anyone receiving a response from a GAMP-registered agent can verify it independently. All they need is the model ID and the signed output — no API key, no account.

from gamp_sdk import GAMPAgent

# Local verification — fetches the public key from the GAMP passport
result = GAMPAgent.verify(
    model_id="mdl_abc123",
    output_text="The capital of France is Paris.",
    signature="BASE64_SIGNATURE_FROM_RESPONSE",
)

print(result["valid"])    # True
print(result["tier"])     # "audited"
print(result["trust_score"])  # 82

const { GAMPAgent } = require('./gamp_sdk.js');

const result = await GAMPAgent.verify({
  modelId: 'mdl_abc123',
  outputText: 'The capital of France is Paris.',
  signature: 'BASE64_SIGNATURE',
});

console.log(result.valid);       // true
console.log(result.tier);        // "audited"
console.log(result.trustScore);  // 82

POST /models/{model_id}/verify-output

{
  "output_text": "The capital of France is Paris.",
  "signature": "BASE64_SIGNATURE",
  "output_hash": "SHA256_HASH"
}

// Response
{
  "valid": true,
  "tier": "audited",
  "trust_score": 82,
  "status": "active",
  "model_name": "MyModel v2",
  "message": "Output signature valid."
}

JavaScript SDK

The JavaScript SDK works in Node.js. It uses the Web Crypto API and has no npm dependencies for core functionality.

// Download: https://gampid.co.za/sdk/gamp_sdk.js
const { GAMPAgent } = require('./gamp_sdk.js');

// Express — automatic response header signing
const express = require('express');
const app = express();
const agent = new GAMPAgent({
  modelId: process.env.GAMP_MODEL_ID,
  privateKeyPem: process.env.GAMP_PRIVATE_KEY,
});

app.use(agent.expressMiddleware());
// Every response now has a GAMP-Signature header
// verifiable by any consumer against the public passport

How Audits Work

Declared tier is free and immediate. To move to Verified, Audited, or Accredited tier, you submit documentation for review. Submission can be done through the dashboard or the SDK. Approval is always human — a GAMP reviewer reads every document before any tier upgrade is granted.

Required Documents by Tier

Submitting Documents via SDK

If you generate documentation programmatically — from deployment metadata, automated test runs, or CI pipelines — you can submit documents via the Python SDK instead of the dashboard.

from gamp_sdk import GAMPAuditClient

client = GAMPAuditClient(
    api_key="gamp_your_api_key",   # from dashboard → API Keys
    model_id="mdl_abc123",
)

# Apply for Verified tier
audit = client.apply_for_audit(tier="verified")
audit_id = audit["audit_record_id"]

# Submit documents from files
client.submit_documents_from_files(audit_id, {
    "training_data":       "docs/training_data.md",
    "intended_use_policy": "docs/intended_use.md",
})

# Run automated checks
result = client.run_checks(audit_id)
print(result["auto_check_score"])  # 74/100

# Check status — human review begins after all docs submitted
print(client.get_audit_status())   # "manual_review"

API Keys

API keys are for programmatic access to the GAMP management API — registering models, submitting documents, reading audit status. They are separate from the Ed25519 private key used to sign outputs.

Generate API keys at: Dashboard → Profile → API Keys → Generate New Key. The full key is shown once. Store it securely — it starts with gamp_.

Key Endpoints

Authentication

Models

Registry (public, no auth)

Audit

Swagger API Docs

Every endpoint in the GAMP API is documented and testable interactively through the Swagger UI. No account needed to browse — but you can authenticate and test live calls directly from the browser.