{"id":4403,"date":"2026-05-02T05:04:33","date_gmt":"2026-05-02T05:04:33","guid":{"rendered":"https:\/\/www.coffee.ai\/articles\/attio-crm-public-api-docs\/"},"modified":"2026-09-06T05:01:56","modified_gmt":"2026-09-06T05:01:56","slug":"attio-crm-public-api-docs","status":"publish","type":"post","link":"https:\/\/www.coffee.ai\/articles\/attio-crm-public-api-docs","title":{"rendered":"Attio API Review: Docs, Rate Limits &amp; Developer Insights"},"content":{"rendered":"<p><em>Written by: Doug Camplejohn, CEO &amp; Co-Founder, Coffee | Last updated: September 5, 2026<\/em><\/p>\n<h2 id=\"key-takeaways\">Key Takeaways for Technical Evaluators<\/h2>\n<ul>\n<li>Attio CRM ships comprehensive public API documentation that covers REST endpoints, authentication, webhooks, and published rate limits.<\/li>\n<li>The docs are open without sign-in and include an interactive explorer, an OpenAPI spec, and multi-language code examples.<\/li>\n<li>Attio supports API keys for single-workspace integrations and OAuth 2.0 for multi-workspace apps, with clear scopes and security guidance.<\/li>\n<li>The API is pleasant to build on, yet it still backs a passive CRM that depends on humans for data entry and data quality.<\/li>\n<li>Teams that want to remove manual CRM data entry entirely can <a href=\"https:\/\/www.coffee.ai\/pricing\" target=\"_blank\">explore Coffee\u2019s pricing and plans<\/a>.<\/li>\n<\/ul>\n<h2>Why API Documentation Quality Shapes CRM Integration Success<\/h2>\n<p>API documentation quality directly affects how safely and quickly you can integrate a CRM. Strong docs signal engineering maturity and a vendor that treats developers as core users. Weak docs increase integration risk and slow every project that touches the CRM.<\/p>\n<p>This guide walks through Attio\u2019s documentation structure, authentication, key endpoints, rate limits, and MCP support, then compares Attio with Salesforce and HubSpot. It closes by showing why any passive CRM API, including Attio\u2019s, still leaves the core data-quality problem unsolved and how Coffee\u2019s agent-led model addresses that gap.<\/p>\n<h2>How Attio Organizes Its Public API Documentation<\/h2>\n<p>Attio\u2019s public documentation lives on Mintlify and splits into five sections: Docs, App SDK, REST API, MCP, and SQL. This layout gives developers a clear map of every integration surface before they write a single line of code.<\/p>\n<p>The REST API documentation covers authentication, rate limits, filtering and sorting, pagination, attribute types, and per-endpoint operation pages. Each endpoint page includes code examples in cURL, Python, JavaScript, PHP, Go, Java, and Ruby. <a href=\"https:\/\/pipeline.zoominfo.com\/sales\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">The REST docs also include an interactive API explorer and an in-page AI assistant (\u201cAsk Assistant\u201d)<\/a> that help developers test calls quickly.<\/p>\n<p>The documentation is <a href=\"https:\/\/pipeline.zoominfo.com\/sales\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">publicly accessible without sign-in<\/a>. Evaluators can inspect the full API surface and example calls before creating an account or requesting access.<\/p>\n<h2>Authentication Options: Workspace Tokens and OAuth 2.0<\/h2>\n<p>Attio offers two authentication methods that map cleanly to common integration patterns.<\/p>\n<p><strong>Workspace access tokens (API keys)<\/strong> support single-workspace internal integrations. Teams generate them in Settings \u2192 Developers \u2192 Access tokens. Tokens start with <code>sk_<\/code> and <a href=\"https:\/\/claudeskills.info\/skills\/jeremylongshore\/claude-code-plugins-plus-skills\/attio-install-auth\" target=\"_blank\" rel=\"noindex nofollow\">remain valid until explicitly revoked<\/a>. Tokens carry no scopes by default, so developers must add scopes such as <code>record_permission:read-write<\/code>, <code>list_entry:read<\/code>, and <code>webhook:read-write<\/code> when creating them.<\/p>\n<p><strong>OAuth 2.0<\/strong> supports multi-workspace applications. Attio implements the <a href=\"https:\/\/pipeline.zoominfo.com\/sales\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">Authorization Code Grant (RFC 6749)<\/a>, with app registration handled in the developer dashboard at <code>build.attio.com<\/code>. Users authorize at <code>https:\/\/app.attio.com\/authorize<\/code>, and the app exchanges the authorization code for a Bearer token via POST to <code>https:\/\/app.attio.com\/oauth\/token<\/code>.<\/p>\n<p>A basic authenticated request uses the Bearer token like this example:<\/p>\n<pre><code>curl -X GET \"https:\/\/api.attio.com\/v2\/objects\" \\ -H \"Authorization: Bearer YOUR_ACCESS_TOKEN\" \\ -H \"Content-Type: application\/json\"<\/code><\/pre>\n<p>Attio\u2019s security guidance recommends one token per integration, storage in a secrets manager, no exposure in browsers or Git, and prompt revocation when tokens are no longer needed.<\/p>\n<h2>Core Endpoints and What They Enable<\/h2>\n<p>Attio\u2019s endpoint catalogue sits under the <code>\/v2\/<\/code> base path and covers several resource groups.<\/p>\n<ul>\n<li><strong>Objects and records:<\/strong> Full CRUD and upsert across standard objects such as People, Companies, and Deals, plus custom objects. <a href=\"https:\/\/hyperops.fr\/en\/blog\/api-attio-developer-guide\" target=\"_blank\" rel=\"noindex nofollow\">Custom objects created in the workspace follow the same query patterns as standard objects<\/a>.<\/li>\n<li><strong>Lists and list entries:<\/strong> Process and grouping management, with entries that carry process-specific data. <a href=\"https:\/\/hyperops.fr\/en\/blog\/api-attio-developer-guide\" target=\"_blank\" rel=\"noindex nofollow\">A single record can appear in multiple lists without duplication<\/a>.<\/li>\n<li><strong>Notes, tasks, comments, and threads:<\/strong> Collaboration features exposed through the API.<\/li>\n<li><strong>Files, meetings, and call recordings:<\/strong> Including access to Attio\u2019s Call Intelligence data.<\/li>\n<li><strong>Webhooks:<\/strong> Event-driven integrations with <a href=\"https:\/\/hyperops.fr\/en\/blog\/api-attio-developer-guide\" target=\"_blank\" rel=\"noindex nofollow\">at-least-once delivery guarantees and HMAC SHA-256 signing<\/a>.<\/li>\n<\/ul>\n<p><a href=\"https:\/\/pipeline.zoominfo.com\/sales\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">The API supports filtering and sorting on both GET and POST endpoints with compound conditions and offers both limit\/offset and cursor-based pagination<\/a>. To illustrate record creation, here is a minimal POST request that adds a person with an email address:<\/p>\n<pre><code>curl -X POST \"https:\/\/api.attio.com\/v2\/objects\/people\/records\" \\ -H \"Authorization: Bearer YOUR_ACCESS_TOKEN\" \\ -H \"Content-Type: application\/json\" \\ -d '{ \"data\": { \"values\": { \"email_addresses\": [ { \"email_address\": \"jane@example.com\" } ] } } }'<\/code><\/pre>\n<p>Attio publishes an OpenAPI specification that teams can import into Postman or use for client generation. <a href=\"https:\/\/pipeline.zoominfo.com\/sales\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">Attio does not ship an official REST client SDK<\/a>, yet the OpenAPI spec keeps client creation straightforward.<\/p>\n<h2>Rate Limits and Design Considerations for Integrations<\/h2>\n<p>Attio documents workspace-wide limits of 100 reads per second and 25 writes per second. When requests exceed these limits, the API returns HTTP 429 with a <code>Retry-After<\/code> header that usually points to the next second.<\/p>\n<p><a href=\"https:\/\/hyperops.fr\/en\/blog\/api-attio-developer-guide\" target=\"_blank\" rel=\"noindex nofollow\">List records and list entries endpoints add a complexity-based rate limit<\/a>. Each query receives a complexity score based on filters, sorts, and the total record or entry count. <a href=\"https:\/\/revenueflow.com\/blog\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">Scores accumulate across apps and tokens in a sliding ten-second window shared by the workspace<\/a>.<\/p>\n<p>This model creates two distinct 429 responses that need different handling:<\/p>\n<ul>\n<li><a href=\"https:\/\/revenueflow.com\/blog\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">If a single query\u2019s complexity score exceeds the per-query limit, identical retries keep failing<\/a>. The fix is to simplify the query by reducing filters, sorts, or dataset size.<\/li>\n<li><a href=\"https:\/\/revenueflow.com\/blog\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">If the summed windowed score exceeds the limit, waiting allows the window to reset<\/a>. Code must distinguish this case to avoid unnecessary query changes.<\/li>\n<\/ul>\n<p>These limits have direct design consequences. <a href=\"https:\/\/pipeline.zoominfo.com\/sales\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">At the 25 writes-per-second ceiling, a 100,000-record sync requires at least 67 minutes of sustained writes<\/a>, assuming no errors or retries. Integrations should batch writes and plan sync windows accordingly.<\/p>\n<p>Webhook handling introduces a separate concern. <a href=\"https:\/\/automationjinn.com\/blog\/attio-api-guide\" target=\"_blank\" rel=\"noindex nofollow\">Webhook signatures must be verified using the HMAC SHA-256 value in the <code>Attio-Signature<\/code> header, computed against the raw body<\/a>. Re-serializing JSON changes key ordering and breaks verification.<\/p>\n<h2>How Attio Uses MCP for AI-Driven Access<\/h2>\n<p>Attio extends beyond REST by operating a hosted MCP server for AI tools. The server at <code>https:\/\/mcp.attio.com\/mcp<\/code> reached general availability in February 2026. <a href=\"https:\/\/hyperops.fr\/en\/blog\/attio-mcp-ai-claude\" target=\"_blank\" rel=\"noindex nofollow\">Assistants such as Claude, ChatGPT, and Cursor can query and modify Attio data using natural language with OAuth-based authentication<\/a>, so MCP connections do not require API keys.<\/p>\n<p>The MCP server exposes <a href=\"https:\/\/scalekit.com\/blog\/attio-mcp-vs-api\" target=\"_blank\" rel=\"noindex nofollow\">37 structured tools across nine categories, including records, lists, comments, notes, tasks, meetings, emails, workspace management, and reporting<\/a>. <a href=\"https:\/\/request.composio.dev\/boards\/tool-requests\/posts\/attio\" target=\"_blank\" rel=\"noindex nofollow\">MCP rate limits are tier-based per workspace, with separate limits for read, write, search, semantic search, and reporting tools<\/a>.<\/p>\n<p>Several limitations shape when MCP fits. <a href=\"https:\/\/scalekit.com\/blog\/attio-mcp-vs-api\" target=\"_blank\" rel=\"noindex nofollow\">MCP does not expose webhook tools, cannot create objects or attributes, and requires interactive OAuth<\/a>. These constraints keep MCP focused on interactive AI sessions, while the REST API remains the right choice for deterministic, unattended, or webhook-triggered automation. <a href=\"https:\/\/crawlwalkrun.co\/attio-expert-sydney-blog\/using-claude-with-attio-mcp\" target=\"_blank\" rel=\"noindex nofollow\">MCP also includes access to emails and call recordings<\/a> that are not available through the public REST API.<\/p>\n<h2>How Attio Compares to Salesforce and HubSpot for Developers<\/h2>\n<p><strong>Documentation structure and clarity:<\/strong> Attio\u2019s docs feel compact and modern, with five clear sections and no sign-in requirement. Salesforce\u2019s documentation spans many versioned guides for REST, SOAP, Bulk, Tooling, Metadata, Streaming, and Pub\/Sub, across API versions 30.0 through 68.0. It is powerful yet demands heavy navigation. HubSpot now uses date-based API versioning such as <code>\/crm\/objects\/2026-03\/contacts<\/code> and exposes a machine-readable <code>llms.txt<\/code> index for discovery.<\/p>\n<p><strong>Authentication simplicity:<\/strong> Attio offers API keys for single-workspace use and OAuth 2.0 for multi-workspace apps, both as Bearer tokens with explicit scope docs. Salesforce relies on OAuth 2.0 with multiple flows and connected-app configuration, which increases setup time. HubSpot uses OAuth 2.0 for multi-account apps and static access tokens for private, single-account integrations.<\/p>\n<p><strong>Rate limits:<\/strong> As noted in the rate limits section, Attio publishes workspace-wide limits with additional complexity scoring on list endpoints. Salesforce\u2019s limits vary by API type and edition, with composite requests that batch up to 25 subrequests. HubSpot applies tier-based limits that depend on plan and API family.<\/p>\n<p><strong>Feature set:<\/strong> <a href=\"https:\/\/pipeline.zoominfo.com\/sales\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">Attio covers full CRUD on records, lists, notes, tasks, files, meetings, and call recordings<\/a>. <a href=\"https:\/\/pipeline.zoominfo.com\/sales\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">It omits B2B data intelligence endpoints such as external enrichment, buyer intent, or org chart resolution<\/a>. Salesforce spans metadata, streaming, and platform events, while HubSpot offers broad CRM coverage across marketing, sales, and service APIs.<\/p>\n<p>Attio\u2019s documentation stands out as especially developer-friendly for modern REST work. All three platforms, however, expose APIs for passive databases that still rely on humans to keep CRM data current.<\/p>\n<h2>Common Integration Pitfalls With Attio\u2019s API<\/h2>\n<ul>\n<li><strong>Ignoring rate limits:<\/strong> Exceeding 100 reads per second or 25 writes per second triggers 429 responses. Design batching and backoff from the start.<\/li>\n<li><strong>Mishandling the two types of 429 responses:<\/strong> A query that exceeds the complexity score keeps failing if retried unchanged, while a windowed-limit 429 resolves after waiting.<\/li>\n<li><strong>Skipping webhook signature verification:<\/strong> Attio signs every webhook with HMAC SHA-256. Verification must use the raw body, because re-serialization breaks the signature.<\/li>\n<li><strong>Assuming uniform pagination:<\/strong> Some endpoints use limit\/offset and others use cursor-based pagination. Filters and limits must remain identical between cursor calls.<\/li>\n<li><strong>Writing referenced records in the wrong order:<\/strong> A person that references a non-existent company fails. Write companies first, then people.<\/li>\n<li><strong>Using <code>$neq<\/code> instead of <code>$not<\/code>:<\/strong> <a href=\"https:\/\/automationjinn.com\/blog\/attio-api-guide\" target=\"_blank\" rel=\"noindex nofollow\">Attio omits a <code>$neq<\/code> operator<\/a>, so conditions must wrap in <code>$not<\/code>.<\/li>\n<\/ul>\n<h2>Why Coffee\u2019s Agent-Led CRM Solves the Data-Quality Problem<\/h2>\n<p>Attio\u2019s API documentation makes integration work smooth, yet the system still depends on humans to enter and maintain data. 71% of sales reps report spending too much time on data entry, which leaves only 35% of their time for selling. A polished API accelerates tooling, but it keeps the manual data-entry burden in place.<\/p>\n<p>Coffee introduces an autonomous CRM Agent that removes that burden. Unlike passive CRMs that rely on humans to populate records, Coffee automatically captures tasks, connects data streams, and logs interactions by scanning emails and calendars. The agent focuses on getting high-quality data into the system so downstream insights stay accurate.<\/p>\n<figure style=\"text-align: center\"><a href=\"https:\/\/www.coffee.ai\/pricing\" target=\"_blank\"><img decoding=\"async\" src=\"https:\/\/cdn.aigrowthmarketer.co\/1763678186019-5cc1a76ac78e.gif\" alt=\"Build people lists automatically with Coffee AI CRM Agent\" style=\"max-height: 500px\" loading=\"lazy\"><\/a><figcaption><em>Build people lists automatically with Coffee AI CRM Agent<\/em><\/figcaption><\/figure>\n<p>Coffee operates in two models: a standalone AI-first CRM for small to mid-sized businesses and a Companion App that layers the agent on top of existing Salesforce or HubSpot instances. For teams already committed to those platforms, Coffee handles the \u201cdata in\u201d work so the system of record stays accurate without human effort. This API flexibility matters to technical teams; one customer generating tens of millions in revenue used Coffee\u2019s API to script bespoke prompts for custom briefings while the agent handled all data entry automatically.<\/p>\n<figure style=\"text-align: center\"><a href=\"https:\/\/www.coffee.ai\/pricing\" target=\"_blank\"><img decoding=\"async\" src=\"https:\/\/cdn.aigrowthmarketer.co\/1763678641499-bad085f8165f.gif\" alt=\"Building a company list with Coffee AI\" style=\"max-height: 500px\" loading=\"lazy\"><\/a><figcaption><em>Building a company list with Coffee AI<\/em><\/figcaption><\/figure>\n<p>The agent-led advantages show up in daily workflows:<\/p>\n<ul>\n<li><strong>Automatic data entry and enrichment:<\/strong> Coffee scans emails and calendars to populate records, saving reps 8\u201312 hours per week without manual updates.<\/li>\n<li><strong>Unified structured and unstructured data:<\/strong> Coffee brings email text, call transcripts, and structured fields into a single view that preserves historical context.<\/li>\n<li><strong>Pipeline intelligence:<\/strong> Because the agent maintains clean data, pipeline analysis stays accurate without CSV exports or manual reviews.<\/li>\n<\/ul>\n<p>Teams that want to remove manual CRM data entry can <a href=\"https:\/\/www.coffee.ai\/pricing\" target=\"_blank\">see how Coffee eliminates data-entry work<\/a>.<\/p>\n<figure style=\"text-align: center\"><a href=\"https:\/\/www.coffee.ai\/pricing\" target=\"_blank\"><img decoding=\"async\" src=\"https:\/\/cdn.aigrowthmarketer.co\/1763678321672-5c8717cf0024.gif\" alt=\"Create instant meeting follow-up emails with the Coffee AI CRM agent\" style=\"max-height: 500px\" loading=\"lazy\"><\/a><figcaption><em>Create instant meeting follow-up emails with the Coffee AI CRM agent<\/em><\/figcaption><\/figure>\n<h2>Conclusion: Attio\u2019s Strong API vs Coffee\u2019s Agent-First Architecture<\/h2>\n<p>Attio CRM delivers public API documentation that is comprehensive, well-structured, and friendly for developers. The docs cover authentication with API keys and OAuth 2.0, CRUD endpoints for records, lists, notes, tasks, files, meetings, and call recordings, webhooks with at-least-once delivery, published rate limits, an OpenAPI spec, and MCP support through a hosted server at <code>https:\/\/mcp.attio.com\/mcp<\/code>. For technical evaluators focused on integration complexity, Attio performs well.<\/p>\n<p>The core limitation sits in the architecture. Attio\u2019s API exposes a passive database that still depends on humans for data entry, which keeps the data-quality problem in place and costs sales teams hours every week. Better integrations move data faster, yet they still start from human-entered records.<\/p>\n<p>Coffee\u2019s agent-led approach addresses that root cause. The agent handles data input automatically, unifies structured and unstructured information, and surfaces accurate insights while still offering flexible APIs for custom work. Teams that want an AI-first CRM experience without the manual data-entry burden can <a href=\"https:\/\/www.coffee.ai\/pricing\" target=\"_blank\">start a Coffee trial<\/a>.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>Does Attio offer a free tier with API access?<\/h3>\n<p>Yes. <a href=\"https:\/\/pipeline.zoominfo.com\/sales\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">Attio includes API and webhook access on all plans, including the free tier with 3 seats, 50,000 records, and 3 custom objects<\/a>. <a href=\"https:\/\/pipeline.zoominfo.com\/sales\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">There is no separate API pricing and no per-call metering for standard REST API calls<\/a>. <a href=\"https:\/\/pipeline.zoominfo.com\/sales\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">SQL access is plan-gated, and custom objects increase from 3 on Free to unlimited on Enterprise<\/a>. <a href=\"https:\/\/pipeline.zoominfo.com\/sales\/attio-api\" target=\"_blank\" rel=\"noindex nofollow\">AI features like Ask Attio and workflow automation blocks consume credits that vary by subscription tier<\/a>.<\/p>\n<h3>What is the difference between Attio\u2019s MCP server and its REST API?<\/h3>\n<p>Attio\u2019s REST API and MCP server target different integration styles. The REST API supports deterministic, programmatic automation such as scheduled syncs, webhook-triggered workflows, and integrations built with tools like n8n or Zapier. It is the right choice for unattended, high-volume operations.<\/p>\n<p>The MCP server, hosted at mcp.attio.com, focuses on interactive AI sessions where assistants call structured tools using natural language. As covered in the MCP section, MCP exposes a set of tools for reading and updating data but cannot create objects, handle webhooks, or run with headless authentication. Teams typically pair MCP for live, judgment-heavy AI work with the REST API for classical integrations.<\/p>\n<h3>How does Coffee differ from building integrations on top of Attio\u2019s API?<\/h3>\n<p>Integrations on Attio\u2019s API automate data movement between systems while still depending on humans to create that data. Sales reps must take notes, log calls, and update deal stages before any integration can sync those updates elsewhere.<\/p>\n<p>Coffee\u2019s agent removes that manual step. By connecting to Google Workspace or Microsoft 365, the Coffee Agent automatically creates contacts and companies, logs activities, enriches records with job titles and funding data, joins calls to record and transcribe them, and generates post-meeting summaries and follow-up drafts without human input. Coffee also offers API access for custom integrations and can run as a standalone CRM or as a Companion App on top of Salesforce or HubSpot.<\/p>\n<h3>What are the most common mistakes developers make when integrating with Attio\u2019s API?<\/h3>\n<p>The most frequent mistakes involve rate limits, webhooks, pagination, and write ordering. Developers often treat all 429 responses the same, skip or misimplement webhook signature verification, assume uniform pagination, or ignore the need to write referenced records in the correct order. The Common Pitfalls section above explains each of these issues in detail and shows how to avoid them.<\/p>\n<h3>Is Coffee compatible with teams that want to keep Salesforce or HubSpot as their system of record?<\/h3>\n<p>Yes. Coffee runs in two modes. The Standalone CRM replaces legacy platforms for small to mid-sized businesses that have outgrown spreadsheets but find traditional CRMs expensive and maintenance-heavy. The Companion App deploys the Coffee Agent as an intelligent layer on top of an existing Salesforce or HubSpot setup.<\/p>\n<p>After a simple authentication, the agent syncs data, enriches records, and writes insights such as call summaries, next steps, and activity logs back to the primary CRM. Teams keep their existing workflows, quotas, forecasting, and required fields while removing the manual data-entry work that harms data quality. Coffee understands Salesforce and HubSpot deeply, including custom fields, forecasting hierarchies, and required field validation that simpler CRM agents often mishandle.<\/p>\n<section data-read-next=\"true\">\n<h2>Read Next<\/h2>\n<ul>\n<li><a href=\"https:\/\/coffee.ai\/articles\/attio-crm-reviews-alternatives-2026\" target=\"_blank\">Attio CRM In-Depth User Reviews and Alternatives 2026<\/a><\/li>\n<li><a href=\"https:\/\/coffee.ai\/articles\/coffee-vs-attio\" target=\"_blank\">Coffee vs Attio: The Better CRM Choice for 2026<\/a><\/li>\n<li><a href=\"https:\/\/coffee.ai\/articles\/attio-crm-reviews-comparisons-2026\" target=\"_blank\">Attio CRM Review 2026: Real User Reviews &amp; Comparisons<\/a><\/li>\n<li><a href=\"https:\/\/coffee.ai\/articles\/attio-crm-key-features-comparison\" target=\"_blank\">Attio CRM Features vs Salesforce, HubSpot &amp; Coffee (2026)<\/a><\/li>\n<li><a href=\"https:\/\/coffee.ai\/articles\/attio-crm-company-information-handling\" target=\"_blank\">How Attio CRM Handles Company Information vs Coffee<\/a><\/li>\n<\/ul>\n<\/section>\n","protected":false},"excerpt":{"rendered":"<p>Explore Attio&#8217;s API docs, auth options, rate limits, and MCP support. See how Coffee&#8217;s agent-led CRM eliminates integration overhead entirely.<\/p>\n","protected":false},"author":11,"featured_media":4402,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"inline_featured_image":false,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-4403","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/www.coffee.ai\/articles\/wp-json\/wp\/v2\/posts\/4403","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.coffee.ai\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.coffee.ai\/articles\/wp-json\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/www.coffee.ai\/articles\/wp-json\/wp\/v2\/comments?post=4403"}],"version-history":[{"count":2,"href":"https:\/\/www.coffee.ai\/articles\/wp-json\/wp\/v2\/posts\/4403\/revisions"}],"predecessor-version":[{"id":8912,"href":"https:\/\/www.coffee.ai\/articles\/wp-json\/wp\/v2\/posts\/4403\/revisions\/8912"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.coffee.ai\/articles\/wp-json\/wp\/v2\/media\/4402"}],"wp:attachment":[{"href":"https:\/\/www.coffee.ai\/articles\/wp-json\/wp\/v2\/media?parent=4403"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.coffee.ai\/articles\/wp-json\/wp\/v2\/categories?post=4403"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.coffee.ai\/articles\/wp-json\/wp\/v2\/tags?post=4403"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}