Contracts that run inside your own systems.
Contract work shouldn't sit in its own silo, cut off from the tools that run your business. The fynk API connects contract creation, data and documents to the software you already use. Contracts get generated, kept current and put to work on their own, with nobody copying fields between tabs.
fynk, inside the tools you already run on.
Connect contract creation and data to your CRM, your forms and your own apps. The busywork runs itself.
"We had 25 different contract versions before. With centralized templates, we reduced this to one and eliminated massive legal risk."
From CRM to contract
Start free trialA closed deal becomes a contract on its own.
Closed-won lands in the CRM, and somebody opens a template to start typing. Not here. The deal closes in HubSpot or Salesforce and the contract is already built from the right template, deal details in place. Won to signature without drafting a line.
Self-service documents
Get a demoLet people generate their own documents.
Every NDA request landing in someone’s inbox is a small tax on their week. Put a form on your site and the document writes itself the moment it is submitted, straight into the matching template. Customers and partners walk away with their own agreement. Nobody on your side touched it.
Your own front end
Start free trialBuild the experience. fynk works underneath.
Partners and franchisees should not need a login to your contract system. They get documents from your own branded screens instead, while fynk handles the contract logic out of sight. You decide who can create what, and only from templates you have approved."There will be one single source of truth. We will invite externals to the template, comment, sign, and store everything in fynk. That is something everybody will value a lot."
Lucas F. Jamnig Lead Counsel at fiskaly
Bring the archive with you
Get a demoMove years of contracts in programmatically.
A folder of dead PDFs on a file server is not an archive. Point your integration at the API and push them straight in. Each one becomes a real fynk document, with AI reading dates, parties, values and clauses on the way through. Nobody re-types a single field.
The platform behind the connection.
Security you set, versions that stay put, and the muscle to run contracts at scale.
Access you control.
Each integration gets its own scoped token. Revoke it whenever, and it keeps running after the person who set it up leaves.
Stable versions.
Your account stays pinned to one API version with a full changelog. New fynk releases never break what you built.
Built for volume.
Generate, sync and move contracts in bulk. Every response reports your remaining rate limit, so your integration paces itself.
Less busywork.
Documents, fields and metadata all managed programmatically. The repetitive drafting and data entry runs itself.
Fits your stack.
Wire contract data into your CRM, ERP or internal apps, so contracts live inside the workflow instead of off to the side.
Compliance ready.
GDPR compliant throughout, with simple, advanced and qualified electronic signatures for regulated markets.
Reporting
Start free trialContract numbers, sitting next to the rest.
Contract data locked inside one tool is contract data nobody looks at. Pull values, durations, tags and statuses into Looker, Power BI or Tableau and they line up beside the rest of your numbers. The whole company reads from one picture."If we get contracts from others, I upload them into the system so that I have an overview of all contracts with all the expiry dates, exclusivity, everything."
Alina Heiner Founder of Maven
Straight into signing
Get a demoYour systems start the signature run.
Somebody still has to open the contract tool and press send. Not anymore. The API adds the signatories, sets the order they sign in, and moves a contract from draft through review into signing. Where the paperwork is regulated, you pick simple, advanced or qualified on the way in.
Signed and filed
Start free trialExecuted contracts land where they belong.
Downloading a signed PDF and re-filing it by hand is how contracts go missing. Once a document is signed, the API hands its final revision straight to your DMS, records system or cloud storage. Every executed agreement ends up archived in the right place.
fynk calls you
Get a demoYour systems hear about it the moment it happens.
Polling on a timer means you find out late. Let fynk post to your endpoint the second a contract is signed, an approval clears or a renewal date comes into view. Every delivery is signed so you can prove it came from fynk, and retried if your endpoint is having a bad day.
Access on your terms
Start free trialEvery integration gets its own key.
One shared key that everything uses is one key you can never rotate. Each integration gets its own token instead, scoped to exactly what it should touch: a reporting job reads, a CRM connection creates. Set an expiry, revoke it on the spot. Tokens belong to the account, not to a person.
Getting your first call through takes about a minute
Everything happens in your fynk account. No approval process, no sandbox to request
- Step 1
Create an API token in your fynk account under Settings > Integrations > API and give it a role.
- Step 2
Send the token in the HTTP Authorization header. Every endpoint is listed in the official documentation .
- Step 3
Point your application at fynk and start creating documents, parties, metadata and signature runs.
What the API covers
Anything your team does by hand in fynk, an integration can do through the API. It speaks plain REST over HTTPS, so it works from any language that can make an HTTP request.
Creating and filling documents
| What you can do | |
|---|---|
| Create | Generate a document from one of your templates, or upload a PDF straight from your own system. |
| Fill | Set dynamic fields and metadata values, so the document arrives complete rather than half-built. |
| Parties | Add the counterparty and the signatories, and update either as a deal changes. |
| Move it on | Push a document into review, into signing, or mark it done once everything is closed. |
Example: a deal closes in your CRM, and the contract is created, filled, addressed and sent for signature before anyone opens fynk.
Reading contract data back
| What you can do | |
|---|---|
| Find | List and filter documents and templates by the stages, tags and metadata your account actually uses. |
| Extract | Read dynamic fields, metadata values, parties and signatories for reporting or a downstream sync. |
| Download | Fetch the final signed PDF revision once a document is executed. |
| Get notified | Have fynk post to your endpoint on signature, approval or renewal, rather than polling on a timer. |
Every webhook delivery is signed, so your endpoint can verify it genuinely came from fynk before acting on it.
What keeps it stable
| Versioning | Your account is pinned to one API version, with a changelog for every change. New releases do not move underneath you. |
| Rate limits | Every response reports what you have left, so a bulk job can pace itself instead of guessing. |
| Tokens | Scoped by role, optionally time-limited, revocable at any moment, and owned by the account rather than a person. |
The full endpoint reference, data models and example requests live in the API documentation .
More product features to explore.
Draft.
Create contracts from proven templates. Fast, consistent, and ready to send.
Boost.
AI reviews, summarizes, and explains your contracts so you never miss what matters.
Sign.
Send contracts for legally binding e-signatures, tracked from sent to signed.
Insights.
See the full picture of your contracts with dashboards, search, and smart alerts.
Your integration inherits every guarantee.
European by design.
Designed and developed in Austria. Hosted exclusively in ISO 27001-certified German data centers, under European law.
Security at the core
End-to-end encryption and secure engineering standards across a continuously monitored infrastructure.
Tokens on your terms
Each token is scoped by role, can carry an expiry, and is revocable at any time. Every call it makes lands in the audit trail.
GDPR, fully embedded
Fully compliant with European data protection regulations, supported by regular audits and external penetration testing.
Widely trusted by companies worldwide
Frequently asked questions.
It is a REST API that connects fynk's contract workflows to your own systems. You can create documents from templates, read and update contract data, and pull records into other tools. It runs in the background, so contracts happen where your business already works.
Create documents from your templates or from an uploaded PDF, read and update dynamic fields and metadata, add parties and signatories, move a contract through review and into signing, and download the signed PDF when it is done. Your templates, tags, teams and document types are all there to work with, so nothing has to be rebuilt.
Yes, and it works both ways. fynk posts events to your own endpoint the moment a document moves into signing, gets signed by all parties, clears an approval checkpoint, or hits a renewal reminder, and every delivery is signed so you can verify it came from fynk. Your CRM, ERP or database can also request the latest fields whenever it needs them.
Create an API token in your fynk account under Settings, Integrations, API, assign it a role such as template reader or document manager, and send it in the HTTP Authorization header on every call. The secret is shown once and stored hashed after that.
Nothing breaks. Access tokens belong to the account, not to a person, so integrations keep running through staff changes. Account owners issue each token, scope it by role, and can revoke it at any time.
Yes. It is a plain REST API over HTTPS, so anything that can make an HTTP request works: JavaScript, Python, Go, Java, PHP and the rest. Example requests for every endpoint are in the official documentation.
Only account owners can issue tokens. Each one is scoped by role, can carry an optional expiry, and shows its secret once before it is stored hashed. API access is available on the Business and Pro plans.
Yes. Documents created through the API use your existing templates, dynamic fields and metadata. Once created, they enter fynk like any other document and follow the same approval and signing setup you already run.
Still have questions?
Take control of your agreements. Move your business forward.
Run agreements the way they should run: fast, clear, and on your terms.
No setup headaches
Go live in days, not quarters
No lock-in
Full export anytime
No hidden fees
Unlimited signatures included