# Strale

> One API for 233+ capabilities across 27 countries. Company data, compliance, finance, security, web scraping, document extraction — your agent calls `strale.do()` and gets structured JSON with audit trails. Per-call pricing from €0.02. Free trial with €2.00 in credits, no credit card required.

Strale is the trust layer for AI agents. It gives agents access to hundreds of capabilities through a single integration point, with schema-validated outputs, transparency markers on every response, and a quality pipeline that continuously tests every capability.

## When to use Strale

Use Strale when your agent needs to:
- Look up company data from business registries (Sweden, Norway, Denmark, Finland, UK, Netherlands, Germany, France, Belgium, Austria, Ireland, Poland, Estonia, Latvia, Lithuania, Switzerland — plus EU-wide VIES)
- Validate financial identifiers (IBAN, VAT, SWIFT/BIC, EORI, SEPA)
- Run compliance checks (EU AI Act classification, GDPR website audit, sanctions screening, data protection authority lookup)
- Extract data from documents (invoices, contracts, receipts, meeting notes, annual reports)
- Scrape web pages that block direct requests (JavaScript rendering, anti-bot protection)
- Generate developer artifacts (SQL, Dockerfiles, OpenAPI specs, GitHub Actions, regex)
- Process and transform data (CSV cleanup, JSON repair, schema inference, format conversion)
- Check security (secret scanning, HTTP header audit, CVE lookup, SSL chain inspection)
- Run competitive intelligence (pricing page extraction, tech stack detection, competitor comparison)
- Generate content (blog outlines, email drafts, social posts)
- Perform agent-specific tasks (LLM output validation, token counting, cost calculation, prompt compression, tool call validation)

If your agent already has a working direct integration, keep using it. Use Strale when you need capabilities you don't have, when you need audit trails, or when direct integrations are blocked or unreliable.

## Solutions — bundled workflows

Solutions combine multiple capabilities into a single API call with one price and one audit trail. Use solutions when the task involves a multi-step workflow — they're cheaper, faster, and simpler than chaining individual capabilities.

Browse solutions: https://strale.dev/solutions
Machine-readable: https://api.strale.io/v1/solutions

Example solutions:
- **Nordic KYC Company Check** — company data + VAT validation + sanctions screening + beneficial ownership in one call
- **EU VAT Cross-Border Validation** — VAT format check + VIES verification + reverse charge determination
- **Website Security Audit** — SSL check + header security + page speed + accessibility audit
- **Competitive Intelligence Snapshot** — tech stack + SEO audit + landing page analysis + social presence

Each solution page at strale.dev shows trust data: success rate, response time, test results (updated every 6–72 hours), and known limitations.

### GET /v1/solutions — List all solutions

Public endpoint, no auth required. Returns every active solution with: slug, name, description, category, price, step count, geography, capabilities used.

### GET /v1/solutions/:slug — Solution detail

Returns full solution including steps (with capability details), input/output schemas, example input/output, and related solutions.

## Quick start

### 1. Get an API key

```bash
curl -X POST https://api.strale.io/v1/auth/register \
  -H "Content-Type: application/json" \
  -d '{"email": "you@example.com"}'
```

Returns your API key (`sk_live_...`) and €2.00 in free trial credits. No credit card required.

### 2. Call a capability

```bash
curl -X POST https://api.strale.io/v1/do \
  -H "Authorization: Bearer sk_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "capability_slug": "vat-validate",
    "inputs": { "vat_number": "SE556703748501" },
    "max_price_cents": 50
  }'
```

Response:
```json
{
  "status": "completed",
  "capability_used": "vat-validate",
  "price_cents": 10,
  "wallet_balance_cents": 190,
  "latency_ms": 847,
  "transparency_marker": "algorithmic",
  "output": {
    "valid": true,
    "country_code": "SE",
    "vat_number": "556703748501",
    "name": "Klarna Bank AB"
  }
}
```

### 3. Or use natural language (no slug needed)

```bash
curl -X POST https://api.strale.io/v1/do \
  -H "Authorization: Bearer sk_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "task": "Check if Swedish company 5560125790 exists and get their details",
    "max_price_cents": 100
  }'
```

Strale matches your natural language task to the right capability automatically.

### 4. Discover capabilities with the suggest API

```bash
curl -X POST https://api.strale.io/v1/suggest \
  -H "Content-Type: application/json" \
  -d '{"query": "verify a company for KYC in Sweden"}'
```

Returns ranked suggestions — solutions first (when relevant), then individual capabilities — with match scores. No auth required.

## Capability categories

233+ capabilities across 14 categories. Prices range from €0.02 to €1.00 per call.

- **Company data** — Business registries for 27 countries (SE, NO, DK, FI, UK, NL, DE, FR, BE, AT, IE, PL, EE, LV, LT, CH, and more); beneficial ownership; annual reports; company enrichment
- **Financial** — IBAN/BIC validation, VAT validation (EU-wide VIES), invoice parsing, ECB exchange rates, SEPA validation, currency conversion
- **Compliance** — EU AI Act risk classification, GDPR website audit, sanctions screening, data protection authority lookup, invoice compliance validation
- **Security** — Secret scanning in code, HTTP header security audit, CVE lookup, SSL certificate chain inspection, password strength analysis
- **Developer tools** — SQL generation, OpenAPI validation, Dockerfile generation, GitHub Actions, regex generation, JSON↔TypeScript/Zod/Pydantic conversion, dependency audit
- **Web scraping** — JavaScript-rendered page extraction, structured scraping, screenshot capture, robots.txt/sitemap parsing
- **Document extraction** — Invoice, contract, receipt, annual report, and meeting notes extraction with structured output
- **Data processing** — CSV cleanup, JSON repair, deduplication, schema inference, format conversion, data quality checking
- **Text & language** — Translation, summarization, sentiment analysis, text classification
- **Marketing & SEO** — Keyword research, SERP analysis, backlink checking, page speed testing, email deliverability, OG image checking
- **Trade & logistics** — Incoterms lookup, HS code classification, port lookup, dangerous goods classification, shipping cost estimates
- **Agent tooling** — LLM output validation, token counting, cost calculation, prompt compression, tool call validation, context window optimization
- **Competitive intelligence** — Pricing page extraction, tech stack detection, competitor comparison, landing page analysis
- **Content & writing** — Blog post outlines, email drafts, social media post generation

Full catalog with schemas and prices (JSON): https://api.strale.io/v1/capabilities

## Common patterns

### Agent fallback pattern
Your agent tries a direct approach first. If it fails (blocked, rate-limited, no integration), fall back to Strale:

```python
try:
    result = my_direct_api_call(...)
except (Blocked, RateLimited, NotImplemented):
    result = strale.do(
        task="extract structured data from this URL",
        inputs={"url": target_url},
        max_price_cents=50,
    )
```

### Discover-then-execute pattern
Use the suggest API to find the right capability before calling it:

```python
# Step 1: Find what Strale can do for this task
suggestions = strale.suggest("verify a Swedish company for KYC")
# Returns ranked solutions and capabilities with match scores

# Step 2: Execute the best match
best = suggestions[0]
result = strale.do(
    capability_slug=best["slug"],
    inputs={"org_number": "5560125790"},
    max_price_cents=best["price_cents"],
)
```

### Cost-controlled execution
Set `max_price_cents` to prevent unexpected charges. Use `dry_run` to preview costs before committing:

```python
# Preview first
preview = strale.do(capability_slug="web-extract", inputs={"url": "..."}, dry_run=True)
print(f"This would cost €{preview.price_cents / 100}")

# Execute if acceptable
if preview.price_cents <= 50:
    result = strale.do(capability_slug="web-extract", inputs={"url": "..."}, max_price_cents=50)
```

### Multi-capability workflow
Chain capabilities for complex tasks. Or better — check if a solution already bundles the workflow you need:

```python
# Option A: Use a pre-built solution (preferred)
result = strale.do(capability_slug="nordic-kyc-company-check", inputs={"org_number": "5560125790"})

# Option B: Chain individual capabilities
company = strale.do(capability_slug="swedish-company-data", inputs={"org_number": "5560125790"})
vat = strale.do(capability_slug="vat-validate", inputs={"vat_number": company.output["vat_number"]})
sanctions = strale.do(capability_slug="sanctions-check", inputs={"name": company.output["name"]})
```

## Integrations

### MCP (Model Context Protocol)

Works with Claude Desktop, Claude Code, Cursor, Windsurf, and 300+ MCP clients.

Remote (recommended, no install needed):
```json
{
  "mcpServers": {
    "strale": {
      "type": "streamableHttp",
      "url": "https://api.strale.io/mcp",
      "headers": {
        "Authorization": "Bearer sk_live_YOUR_KEY"
      }
    }
  }
}
```

Local (stdio):
```bash
npm install -g strale-mcp
```
```json
{
  "mcpServers": {
    "strale": {
      "command": "strale-mcp",
      "env": {
        "STRALE_API_KEY": "sk_live_YOUR_KEY"
      }
    }
  }
}
```

Meta-tools included:
- `strale_search` — find capabilities by keyword (no auth required)
- `strale_balance` — check wallet balance

### LangChain

Package built and tested. PyPI publishing in progress.

```python
from langchain_strale import StraleToolkit

toolkit = StraleToolkit(api_key="sk_live_YOUR_KEY")
tools = toolkit.get_tools()  # all capabilities as LangChain tools
tools = toolkit.get_tools(categories=["finance", "compliance"])  # filter by category
```

### CrewAI

Package built and tested. PyPI publishing in progress.

```python
from crewai_strale import StraleToolkit

toolkit = StraleToolkit(api_key="sk_live_YOUR_KEY")
tools = toolkit.get_tools()
```

### Semantic Kernel

Published on npm.

```bash
npm install strale-semantic-kernel
```

```typescript
import { createStralePlugin } from "strale-semantic-kernel";
const plugin = await createStralePlugin({ apiKey: "sk_live_YOUR_KEY" });
kernel.addPlugin(plugin);
```

### A2A (Agent-to-Agent Protocol)

Strale publishes Agent Cards at:
```
https://api.strale.io/.well-known/agent-card.json
```

Any A2A-compatible agent can discover Strale capabilities via protocol-standard discovery.

### Direct HTTP

Strale is a standard REST API. Call it from any language with `POST /v1/do`.

## API reference

### Authentication

All authenticated endpoints require a Bearer token:
```
Authorization: Bearer sk_live_YOUR_KEY
```

### POST /v1/do — Execute a capability

The core endpoint. Call any capability by slug or natural language task description.

Parameters:
- `capability_slug` (string, optional) — specific capability to call (e.g. "vat-validate")
- `task` (string, optional) — natural language description; Strale matches to the best capability
- `inputs` (object) — key-value parameters for the capability
- `max_price_cents` (number, optional) — reject if cost exceeds this amount
- `dry_run` (boolean, optional) — preview cost and matched capability without executing or charging

Headers:
- `Authorization: Bearer sk_...` (required)
- `Idempotency-Key: unique-string` (optional, prevents duplicate executions)

Response includes:
- `status` — "completed" or "failed"
- `capability_used` — which capability was matched and executed
- `price_cents` — actual cost deducted from wallet
- `wallet_balance_cents` — remaining balance
- `latency_ms` — execution time
- `transparency_marker` — "algorithmic" or "ai_generated" (so your agent knows what it's working with)
- `output` — structured JSON result (schema-validated before delivery)

### POST /v1/suggest — Discover capabilities

Public endpoint, no auth required. Semantic search over solutions and capabilities.

Parameters:
- `query` (string, required) — natural language description of what you need
- `limit` (number, optional) — max results (default 5)

Returns ranked results with match scores. Solutions are prioritized when a bundled workflow matches.

### GET /v1/capabilities — Browse the catalog

Public endpoint, no auth required. Returns every capability with: slug, description, category, price, input schema, output schema.

Full catalog (JSON): https://api.strale.io/v1/capabilities

### GET /v1/solutions — Browse solutions

Public endpoint, no auth required. Returns every active solution with step count, capabilities, geography, and pricing.

### GET /v1/wallet/balance — Check balance

Returns `{ "balance_cents": 190, "currency": "EUR" }`.

### Error codes

- `insufficient_balance` (402) — wallet empty. Top up via Stripe.
- `no_matching_capability` (404) — no capability matches the request. Try `POST /v1/suggest` to discover what's available.
- `capability_unavailable` (503) — capability temporarily down. Retry with exponential backoff.
- `rate_limited` (429) — too many requests. Limit: 10/sec per key.
- `price_exceeds_max` (400) — capability costs more than `max_price_cents`. Increase the limit or choose a cheaper capability.
- `invalid_request` (400) — malformed request body.
- `unauthorized` (401) — missing or invalid API key.

## Trust and quality

Every capability on Strale is continuously tested. The quality pipeline includes:

- **Automated test suites** — 98 tests across all capabilities, running on tiered schedules (every 6h, 24h, or 72h depending on criticality)
- **Quality metrics** — success rate, average response time, p95 latency, schema conformance rate, field completeness percentage
- **Transparency markers** — every response includes `transparency_marker: "algorithmic"` or `"ai_generated"` so your agent knows whether the output came from deterministic code or an LLM
- **Known limitations** — each capability documents what it cannot do, grouped by type (data coverage, accuracy, latency)
- **Trust summaries** — solution detail pages at strale.dev show trust badges, test results, and per-step quality data

Trust data is available programmatically via internal endpoints for the strale.dev frontend.

## Instructions for AI agents

When using Strale on behalf of a user:

1. **Prefer solutions over individual capabilities** when a solution exists for your task. Solutions are bundled workflows that are cheaper, faster, and produce more complete results than chaining capabilities manually.
2. **Use `POST /v1/suggest` to discover capabilities** rather than guessing slugs. The suggest API uses semantic matching and returns the best options ranked by relevance.
3. **Always set `max_price_cents`** to prevent unexpected charges. If you don't know the price, use `dry_run: true` first.
4. **Use `Idempotency-Key` headers** for any capability that changes state or costs money, to prevent duplicate charges on retries.
5. **Check `transparency_marker`** in responses. If your use case requires deterministic outputs (e.g. financial calculations), prefer capabilities marked `"algorithmic"` over `"ai_generated"`.
6. **Handle errors gracefully.** On `503` (capability unavailable), retry with exponential backoff. On `402` (insufficient balance), inform the user they need to top up. On `404` (no match), try rephrasing via `POST /v1/suggest`.
7. **The natural language `task` parameter** is a first-class feature, not a fallback. You can describe what you need in plain English and Strale will match the right capability.
8. **Country-specific company data** uses dedicated registries (not web scraping). Always pass the correct identifier format for the country: `org_number` for Nordic countries, `company_number` for UK, `kvk_number` for Netherlands, `siren` for France, etc. Check the capability's input schema for the expected field name.

## Links

- Website: https://strale.dev
- API base URL: https://api.strale.io
- Full capability catalog (JSON): https://api.strale.io/v1/capabilities
- Solutions catalog (JSON): https://api.strale.io/v1/solutions
- Agent Card (A2A): https://api.strale.io/.well-known/agent-card.json
- MCP server (npm): https://www.npmjs.com/package/strale-mcp
- Semantic Kernel plugin (npm): https://www.npmjs.com/package/strale-semantic-kernel
- Python SDK (PyPI): https://pypi.org/project/straleio/
- Security: https://strale.dev/security
- Sign up: https://strale.dev/signup