---
name: Orthogonal
description: Use when agents need to discover, understand, and call third-party APIs (lead enrichment, web scraping, email finding, social intelligence, etc.) through a unified gateway. Agents use Orthogonal to search for APIs, get parameter details, generate code snippets, and execute API calls without managing individual API keys.
metadata:
    mintlify-proj: orthogonal
    version: "1.0"
---

# Orthogonal Skill

## Product Summary

Orthogonal is a unified API gateway that lets agents discover and call third-party APIs through a single authentication layer. Instead of managing separate API keys for each service, agents use one Orthogonal API key to search for APIs (lead enrichment, web scraping, email verification, social intelligence), understand their parameters, and execute calls. The service handles authentication, billing, rate limiting, and retries for each provider. Base URL: `https://api.orthogonal.com/v1`. Key files: API key from dashboard, environment variable `ORTHOGONAL_API_KEY`. CLI: `orth` command for terminal access. MCP server at `https://mcp.orth.sh` for Claude/Cursor integration. Primary docs: https://docs.orthogonal.com

## When to Use

Reach for Orthogonal when:
- An agent needs to call a paid API (enrichment, scraping, search, verification) but doesn't have the API key or documentation
- You want agents to discover APIs dynamically using natural language ("find APIs that enrich leads by email")
- You're building multi-API workflows that chain 2+ services together (search → enrich → verify)
- You need unified billing and credit tracking across multiple API providers
- You're integrating with Claude Desktop, Cursor, or any MCP-compatible agent platform
- You want to avoid managing individual API keys for each service

Do not use Orthogonal for: APIs already integrated directly into your system, internal APIs, or services where you control authentication directly.

## Quick Reference

### API Endpoints

| Endpoint | Method | Purpose |
|----------|--------|---------|
| `/v1/search` | POST | Find APIs by natural language prompt |
| `/v1/details` | POST | Get full parameter info for an endpoint |
| `/v1/run` | POST | Execute an API call |
| `/v1/integrate` | POST | Get code snippets (curl, Node.js, Python) |
| `/v1/list-endpoints` | GET | List all available APIs |

### CLI Commands

```bash
orth search "web scraping"              # Find APIs
orth api olostep                        # View endpoints for an API
orth api olostep /v1/scrapes            # Get endpoint details
orth run olostep /v1/scrapes --body '{...}'  # Execute API call
orth account                            # Check balance and usage
orth skills install company-intel      # Install skill to agent
```

### Authentication

```bash
export ORTHOGONAL_API_KEY=orth_live_xxxxxxxxxxxx
# Or pass with each call: orth --key orth_live_xxxxxxxxxxxx <command>
```

### MCP Server Configuration

Add to Claude Desktop or Cursor:
```json
{
  "mcpServers": {
    "orthogonal": {
      "url": "https://mcp.orth.sh"
    }
  }
}
```

### Request/Response Format

**Request to /v1/run:**
```json
{
  "api": "sixtyfour",
  "path": "/enrich-lead",
  "body": { "lead_info": { "email": "user@example.com" } },
  "query": { "optional_param": "value" }
}
```

**Response:**
```json
{
  "success": true,
  "priceCents": 10,
  "data": { /* API response */ },
  "requestId": "run_xxxxx"
}
```

## Decision Guidance

| Scenario | Use This | Why |
|----------|----------|-----|
| Agent needs to call one API once | `/v1/run` directly | Simplest, no discovery needed |
| Agent must find the right API first | `/v1/search` then `/v1/run` | Search narrows options, then execute |
| Agent needs parameter details before calling | `/v1/details` before `/v1/run` | Understand required/optional fields |
| Building code integration | `/v1/integrate` | Get ready-to-use snippets |
| Terminal/CLI access | `orth` CLI | Faster than API calls for exploration |
| Claude/Cursor integration | MCP server | Native tool integration, no code needed |
| Custom agent platform | REST API tools | Define 5 tools in your platform config |

## Workflow

1. **Understand the task.** What does the agent need to accomplish? (e.g., "enrich leads by email", "scrape competitor pricing")

2. **Search for APIs.** Call `/v1/search` with a natural language prompt to find matching APIs:
   ```bash
   curl -X POST 'https://api.orthogonal.com/v1/search' \
     -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
     -d '{"prompt": "enrich lead find email", "limit": 5}'
   ```

3. **Get endpoint details.** Call `/v1/details` to understand parameters for the chosen endpoint:
   ```bash
   curl -X POST 'https://api.orthogonal.com/v1/details' \
     -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
     -d '{"api": "sixtyfour", "path": "/enrich-lead"}'
   ```

4. **Execute the call.** Use `/v1/run` with the API slug, path, and parameters:
   ```bash
   curl -X POST 'https://api.orthogonal.com/v1/run' \
     -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
     -d '{"api": "sixtyfour", "path": "/enrich-lead", "body": {...}}'
   ```

5. **Chain if needed.** For multi-step workflows, use the output from one call as input to the next (e.g., search → find email → verify email).

6. **Check cost.** Review `priceCents` in the response. Ensure account has sufficient credits.

7. **Verify results.** Confirm the `data` field contains expected output. Check `requestId` for debugging.

## Common Gotchas

- **Missing API key.** Always set `ORTHOGONAL_API_KEY` environment variable or pass `--key` flag. Requests without auth return 401.
- **Insufficient credits.** Calls fail with 402 if account balance is too low. Check dashboard and add credits before retrying.
- **Wrong API slug or path.** Search results return the correct `api` slug and `path` values. Copy them exactly; typos return 404.
- **Body vs query parameters.** Some endpoints use `body` (POST), others use `query` (GET). Check `/v1/details` to see which is required.
- **Rate limiting.** Orthogonal handles retries, but very high volume may hit provider limits. Space out calls if needed.
- **Endpoint not found.** Not all APIs have all endpoints. Use `/v1/list-endpoints` or search to confirm availability.
- **Forgetting to chain results.** Multi-step workflows require passing output from one call to the next. Don't assume data is available without calling it.
- **Test vs live keys.** Test keys (`orth_test_`) have limited APIs and no charges. Use live keys (`orth_live_`) for production.
- **MCP server not appearing.** Fully restart Claude/Cursor after adding config. Check URL is exactly `https://mcp.orth.sh`.

## Verification Checklist

Before submitting work with Orthogonal:

- [ ] API key is set and valid (test with `orth account` or a simple search)
- [ ] Account has sufficient credits for the planned calls
- [ ] Searched for the right API or confirmed it exists in the catalog
- [ ] Got endpoint details to understand required parameters
- [ ] Request body/query format matches the endpoint specification
- [ ] Response includes `"success": true` (not an error)
- [ ] `priceCents` is within expected budget
- [ ] `data` field contains the expected output structure
- [ ] For multi-API workflows, verified each step's output feeds into the next step's input
- [ ] For MCP integration, confirmed tools appear in Claude/Cursor and respond to test queries
- [ ] Tested with a small batch before scaling to large volumes

## Resources

- **Full documentation:** https://docs.orthogonal.com/llms.txt — comprehensive page-by-page navigation for all agents
- **API Reference:** https://docs.orthogonal.com/api-reference/introduction — all endpoints, parameters, error codes
- **Use Cases:** https://docs.orthogonal.com/use-cases — real-world multi-API workflow examples (lead research, competitor intelligence, ABM, event prospecting)
- **MCP Setup:** https://docs.orthogonal.com/mcp/setup — step-by-step for Claude Desktop, Cursor, and other clients

---

> For additional documentation and navigation, see: https://docs.orthogonal.com/llms.txt