Attio API: Full CRM Access for OpenClaw Agents — No OAuth Headaches

11,132 downloads on ClawHub as of March 2026. The Attio API skill, built by the Maton team, connects OpenClaw agents to Attio — the modern CRM designed around flexible data models — without requiring you to manage OAuth tokens directly.

Attio has become a popular CRM among startups and technical teams who find HubSpot too rigid and Salesforce too heavy. This skill exposes its full REST API surface: people, companies, custom objects, tasks, notes, comments, lists, meetings, and call recordings.

The Problem It Solves

Attio's API is well-designed, but OAuth 2.0 is OAuth 2.0 — there's a redirect flow, a token exchange, refresh logic, and secure storage to set up before you write a single API call. For an agent that just wants to "add a new contact" or "find all open deals," this infrastructure is noise.

Maton's approach is a gateway proxy: you authenticate once through their control panel, they store and refresh your OAuth token, and every subsequent API call routes through gateway.maton.ai/attio/... with a simple API key header. Your agent never sees the OAuth complexity.

Architecture

OpenClaw Agent
     │
     │  Authorization: Bearer $MATON_API_KEY
     ▼
gateway.maton.ai/attio/{path}
     │
     │  OAuth token (managed by Maton)
     ▼
api.attio.com/{path}
     │
     ▼
Your Attio Workspace

The base URL for all requests is:

https://gateway.maton.ai/attio/{native-api-path}

Replace {native-api-path} with any standard Attio REST endpoint. The gateway is a transparent proxy — the request and response formats are identical to Attio's native API.

Quick Start

1. Get a Maton API key

Sign up at maton.ai, go to Settings, copy your API key, and set it as an environment variable:

export MATON_API_KEY="your_key_here"

2. Connect your Attio account

python <<'EOF'
import urllib.request, os, json
data = json.dumps({'app': 'attio'}).encode()
req = urllib.request.Request('https://ctrl.maton.ai/connections', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
result = json.load(urllib.request.urlopen(req))
print(result['connection']['url'])  # open this URL to authorize
EOF

Open the returned URL in a browser to complete OAuth authorization. You only do this once.

3. Test the connection

python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://gateway.maton.ai/attio/v2/objects')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

This lists all objects in your Attio workspace (people, companies, and any custom objects).

Core Operations

Query Records

# Search for a person by email
python <<'EOF'
import urllib.request, os, json
data = json.dumps({
  "filter": {"email_addresses": {"$eq": "[email protected]"}}
}).encode()
req = urllib.request.Request(
  'https://gateway.maton.ai/attio/v2/objects/people/records/query',
  data=data, method='POST'
)
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Create a Record

# Create a new company record
python <<'EOF'
import urllib.request, os, json
data = json.dumps({
  "data": {
    "values": {
      "name": [{"value": "Acme Corp"}],
      "domains": [{"domain": "acme.com"}]
    }
  }
}).encode()
req = urllib.request.Request(
  'https://gateway.maton.ai/attio/v2/objects/companies/records',
  data=data, method='POST'
)
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Add a Note

# Add a note to a record
python <<'EOF'
import urllib.request, os, json
data = json.dumps({
  "data": {
    "parent_object": "people",
    "parent_record_id": "RECORD_ID_HERE",
    "title": "Follow-up call",
    "content": "Discussed Q2 renewal. Decision expected by end of month."
  }
}).encode()
req = urllib.request.Request(
  'https://gateway.maton.ai/attio/v2/notes',
  data=data, method='POST'
)
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Create a Task

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
  "data": {
    "content": "Send contract to Jane by Friday",
    "deadline_at": "2026-03-22T17:00:00.000Z",
    "linked_records": [{"target_object": "people", "target_record_id": "RECORD_ID_HERE"}]
  }
}).encode()
req = urllib.request.Request(
  'https://gateway.maton.ai/attio/v2/tasks',
  data=data, method='POST'
)
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

What Attio Covers (vs Traditional CRMs)

Attio's flexible data model is its core differentiator. Unlike Salesforce or HubSpot where you work with fixed Contact/Lead/Opportunity objects, Attio lets you define any object type — a Job Applicant, a Vendor, a Project — with custom fields and relationships.

This flexibility maps well to agent use cases: your agent can work with whatever data model your team has designed, not a predefined CRM schema.

Multiple Connections

If you manage multiple Attio workspaces, specify which connection to use with a header:

req.add_header('Maton-Connection', 'connection_id_here')

List your active connections:

python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://ctrl.maton.ai/connections?app=attio&status=ACTIVE')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Installing the Skill

clawhub install attio-api

Set your Maton API key in your environment:

export MATON_API_KEY="your_maton_api_key"

The skill also requires you to have completed OAuth authorization at ctrl.maton.ai at least once for your Attio workspace.

Practical Tips

Test the connection before complex queries. Run a simple GET /v2/objects to confirm your Maton API key and OAuth connection are working before building more complex workflows.

Check your object slugs. Attio uses slugs like people, companies, or your custom object slug (e.g., job-applicants) in API paths. These are visible in your Attio workspace settings — don't guess.

Use the Maton control panel for connection management. ctrl.maton.ai shows all your active OAuth connections. If something stops working, a stale or revoked token here is usually the cause.

Attio's filter syntax is powerful. The query endpoint supports $eq, $gt, $contains, $is_empty, and compound filters. Read Attio's filter docs to build precise queries instead of filtering large result sets in your agent.

This skill covers the full API. Notes, tasks, lists, list entries, meetings, call recordings, comments, and workspace data are all accessible — not just contacts and companies. If Attio has an API endpoint for it, this skill can reach it.

Considerations

Maton dependency. This skill routes through Maton's gateway. If maton.ai has downtime, your Attio API calls fail. For production-critical workflows, check Maton's status page.

API key security. Your MATON_API_KEY grants full access to all your connected apps (Attio and any other apps you've connected to Maton). Treat it like a password and store it in .env, not in code.

Rate limits apply. Attio's API has rate limits (500 requests/minute on most plans). High-frequency agent workflows should add delays between calls or use batched operations.

Low install count. 11,132 downloads but only 2 installs — this pattern suggests it's being pulled as a dependency or evaluated but not widely deployed yet. Attio itself has a smaller user base than HubSpot or Salesforce, which limits the audience.

The Bigger Picture

The Maton gateway pattern — managed OAuth, single API key, transparent proxy — is a smart architecture for agent-accessible SaaS integrations. Building OAuth flows inside individual skills is fragile and hard to maintain. Externalizing auth to a dedicated service means the skill stays simple and the auth layer stays secure.

As more CRMs, project management tools, and productivity apps adopt this approach, the agent integration ecosystem becomes dramatically easier to work with. The Attio API skill is a good example of what a clean agent-to-SaaS connection looks like.

View the skill on ClawHub: attio-api