Every tool your contract touches.

ChatGPT

The contract tools show up next to everything else you ask it for.

Claude

Ask for a contract in the same chat where you worked out the terms.

Claude Code

Contract steps inside the same terminal session as the build.

Cursor

Ship the integration and send the contract from one editor.

Windsurf

Same MCP tools, same account, inside Windsurf.

Your own agent

Dynamic client registration means no ticket to us to get connected.

Cline

An autonomous coding agent that can also close the paperwork.

Goose

Block’s open agent framework, wired over MCP.

LangChain

Load the MCP tools straight into your own agent.

LlamaIndex

Index what you signed, not just what you drafted.

OpenAI Agents SDK

Hosted MCP means no wrapper code to maintain.

Raycast

Contract actions a keystroke away from anything else you do.

Vercel AI SDK

Put signing inside your own product’s assistant.

VS Code

Any MCP-capable extension can hold the same ten tools.

Warp

Terminal-native agent access to the full signing lifecycle.

Zed

Connects through the same MCP server as every other client.

HubSpot

The deal already holds the terms. Stop retyping them.

Affinity

Relationship data becomes signer data.

Attio

Records stay current without anyone remembering to update them.

Close

Built for reps who live in one screen. Keep it that way.

Copper

Google Workspace teams get the same contract trail.

Dynamics 365

Enterprise CRM, same lifecycle, driven from your side.

Folk

Small teams, tidy records, no contract left in someone’s inbox.

Outreach

The sequence ends in a signature, not another follow-up.

Pipedrive

Move the deal when the signature lands, not when someone notices.

Salesforce

Opportunity closed-won is the cleanest trigger there is.

Salesloft

Cadences and contracts on the same timeline.

Zoho CRM

Deals in, signed contracts back, no manual export.

HubSpot marketplace app

Self-serve install with your own OAuth grant, not our token.

Salesforce managed package

A native AppExchange install, so admins do not write code.

Ashby

Offer approved in Ashby, offer letter out the same minute.

BambooHR

The employee file stays complete without anyone filing.

Deel

Contractor agreements across borders, same lifecycle.

Greenhouse

Stop rebuilding the same offer letter for every hire.

Gusto

Payroll needs the signed version, not the draft.

HiBob

People data in, signed paperwork back.

Justworks

PEO onboarding without the paperwork bottleneck.

Lever

Offer stage and signature stage should be the same stage.

Personio

European HR teams get the same one-step filing.

Remote

Hire anywhere, sign in the same flow.

Rippling

Onboarding should not start with a chased PDF.

Workable

One less spreadsheet between offer and start date.

Workday

Worth doing properly, not with a bolted-on script.

Fathom

The recap already lists what you agreed. Use it.

Fireflies

The terms were agreed on the call. Read them from the call.

Gong

Revenue intelligence that ends in signed paper.

Google Calendar

Deadlines in a contract belong on a calendar.

Google Meet

The call ends and the paperwork is already moving.

Grain

Highlights become clauses.

Otter

Transcript to draft with nothing retyped.

Outlook Calendar

Same idea, Microsoft side of the house.

Read AI

Action items that include the contract itself.

Zoom

Send it while the call is still on screen.

Circleback

Notes to signed contract, once there is a write path worth using.

Granola

Great notes, no public write path yet.

Email

Signers never install anything. They get an email and they sign.

Front

Shared inboxes should not lose track of a contract.

Gmail

Half of all contracts start as an email attachment.

Intercom

Send the agreement inside the conversation that asked for it.

Outlook

The redline arrived by email. Start from there.

Twilio

For signers who answer texts and ignore email.

Zendesk

Ticket to contract without leaving the ticket.

Discord

For teams and communities that live here instead.

Microsoft Teams

Same updates, Microsoft side of the house.

Slack

The channel finds out when it happens, not at standup.

Telegram

A bot channel that mirrors every lifecycle event.

Slack app

Install once, approve from the message, no webhook plumbing.

Amazon S3

Your bucket, your retention rules, your copy of everything.

Box

Governed storage for the version that counts.

Coda

Docs that behave like apps, contracts that behave like rows.

Confluence

Internal record of what was agreed, kept honest.

Dropbox

One place for executed paper, kept current.

Egnyte

Regulated industries still need the signed file filed.

Google Docs

Redlines finish here. Signature should start here.

Google Drive

The draft lives here. The signed copy should too.

Notion

The contracts database everyone already opens.

OneDrive

Microsoft shops file the same way, just elsewhere.

SharePoint

Document libraries are where contracts go to be found again.

Bill

Vendor agreements and the payments that follow them.

Brex

Procurement records that include the paper.

Chargebee

Subscription terms come from the contract, so read the contract.

Maxio

Usage plans still start with a signed order form.

Mercury

Small teams want the signed doc next to the money movement.

NetSuite

Revenue recognition wants the executed document, not a summary.

Paddle

Merchant of record, same signature trigger.

QuickBooks

Finance should not learn about a closed deal from Slack.

Ramp

Signed vendor contract, then the spend limit, in that order.

Recurly

Signature to first charge with nothing in between.

Xero

Signed value lands in the books without a rekey.

Stripe

Signature is the moment you are allowed to charge. Charge then.

Anrok

Tax treatment reads off contract terms. Worth doing natively.

Airtable

The contract tracker most teams already built by hand.

Asana

Onboarding projects that start themselves.

Basecamp

Client projects that begin with a signed agreement.

ClickUp

One task per contract, updated by the contract.

Height

Tasks that know whether the paper is done.

Jira

The implementation ticket should not wait for someone to notice.

Linear

A signed contract usually means work starts. Create the work.

Monday

Boards stay accurate without a weekly cleanup.

Productboard

Commitments in contracts should reach the roadmap.

Shortcut

Delivery work created from signed scope.

Smartsheet

Rollups that reflect what is actually signed.

Trello

Cards that move when the paperwork moves.

Apollo

Find the person who can actually sign it.

BigQuery

Stream signing events straight into your analytics stack.

Clay

Enrichment tables that can also produce contracts.

Clearbit

Legal entity names are the field people get wrong most often.

Databricks

Executed terms are structured data. Treat them that way.

Hex

Answer why contracts stall, with the actual timestamps.

Metabase

A contract dashboard anyone on the team can read.

People Data Labs

Programmatic enrichment for programmatic contracts.

Snowflake

Contract outcomes belong in the warehouse, not a spreadsheet.

ZoomInfo

Signer details verified before the envelope goes out.

Segment

One event stream, every downstream tool fed at once.

Census

Reverse sync back into the tools your team lives in.

Fivetran

A managed source connector, so nobody maintains a sync script.

API keys

A key per integration, rotatable, scoped to your account.

Audit certificate

Who signed, when, from where, on one page you can hand a lawyer.

OAuth for agents

Agents connect themselves. No key pasted into a chat window.

Signed webhooks

Every event carries an HMAC so you can prove it came from us.

Google Workspace SSO

Directory-backed access for Workspace teams.

JumpCloud

Directory and device teams get the same path.

Microsoft Entra ID

Same story on the Microsoft side.

Okta

Waiting on SAML, which is waiting on nothing but us.

OneLogin

Lands with the rest of the SAML work.

Qualified signatures

eIDAS qualified signing for the contracts that require it.

SAML SSO

Dashboard sign-in through your identity provider.

SCIM provisioning

Joiners and leavers handled by your directory, not by us.

Signer ID checks

Document and selfie verification before a high-value signature.

Clio

Engagement letters that do not need chasing by hand.

iManage

Law firm document management, fed the executed version.

NetDocuments

Cloud DMS with the signed copy where it belongs.

Signed archive export

Your executed contracts are yours. Take a full copy any time.

Adobe Acrobat Sign

On the migration list with the rest.

DocuSign

An importer for the archive you already paid for.

Dropbox Sign

Same importer, different source.

Evisort

Contract analytics wants the whole executed set.

Icertis

Enterprise CLM, on the list.

Ironclad

Full CLM sync is a real project, not a webhook.

LinkSquares

Repository sync with extracted terms, done properly or not at all.

PandaDoc

Templates and executed documents, brought over.

Atlas REST API

The whole lifecycle, from create to signed PDF, over HTTP.

Contract extraction

Signed contracts come back as fields, not as a PDF to read.

Delivery log and replay

See exactly what we sent, and send it again.

Document from URL

Give us a link to a PDF or DOCX and skip the upload step.

Live status stream

Server-sent events, for when polling feels wrong.

MCP server

Ten tools that cover the whole lifecycle, hosted, no wrapper code.

Outbound webhooks

Signed events for every state change, retried when your endpoint blinks.

Templates API

Repeat sends without re-detecting fields every time.

AWS Lambda

Your own handler, your own VPC, our events.

Cloudflare Workers

Verify the signature at the edge and fan out from there.

GitHub Actions

Contracts as part of a pipeline, not a person.

Retool

An internal contract console in an afternoon.

Vercel Functions

Drop a route in your app and you have an integration.

Make

Visual scenarios driven by real contract events.

n8n

Self-hosted automation, same signed events.

Pipedream

A few lines of code between our event and your system.

Tray

Same pattern, different platform.

Workato

Enterprise iPaaS, wired through webhooks and the API.

Zapier

Catch the event, do the rest, no code on your side.

Zapier app

A listed app with real triggers and actions, not a raw hook.