- Brand
- fynk
- Category
- Operations
- Primary Subcategory
- Contract Lifecycle & Review
Integration details
Description
Use fynk for contract management, document automation and e-signature workflows in ChatGPT. Search existing contracts, create NDAs and client agreements from templates, fill document fields, update counterparties and signatories, and send documents for signature when requested. Track signing status and organize agreements with tags and teams. For founders, operators, sales and legal teams working in AI assistants, fynk connects the deal details in your conversation to documents and workflows in your account. Use it to prepare an agreement from a template, find contracts with a customer, or check which documents are waiting for signatures. Connect an existing fynk account using OAuth. Available tools and accessible documents follow your fynk permissions. Creating a draft and starting its signing process are distinct actions; review the document and recipient details before requesting signature invitations.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- Contract Lifecycle & Review
- Secondary Subcategories
- None listed
- Brand
- fynk
- Access
- Account required
- First tracked
- 2026-11-15
- Tool count
- 76
- Market
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Not discoverable in ChatGPT yet
ChatGPT now suggests Plugins on its own when they match a user's request, but not every Plugin is being surfaced yet.We haven’t seen fynk suggested yet. Sign up and we’ll track it, and your Discoverability Score will appear here once ChatGPT starts surfacing it.
What discovery looks like

Get alerts for fynk
Get updates when fynk’s Discoverability Score or category rank changes.
Competing in ChatGPT Contract Lifecycle & Review
View Category76 tools agents can invoke
Archives a document, hiding it from the account's default document lists. Use this tool when: - A document is no longer actively worked with and should be moved out of the way - The user asks to archive, hide, or clean up a document Archiving does not delete anything: the document keeps all its data and can be restored later with the restore-document tool. The document must not already be archived.
archive-document
Add one or more account users as members of a team. Use this tool when: - The user asks to add people to a team Membership can give people access to the documents, templates, imports and automations assigned to the team, subject to their own permissions, so confirm who is being added when the user's request leaves room for doubt. Existing members of the team are preserved. Use detach-account-users-from-team to remove members. Pass `account_user_uuids` from list-account-users, list-account-team-members (when copying members between teams), or the account-user uuids the user references.
attach-account-users-to-team
Create a new custom document type for the account. Use this tool when: - The user asks for a new kind of document to be distinguished, e.g. "add a Framework Agreement document type" - A document or template needs a document type that the account does not have yet Call list-account-document-types first: fynk already provides system document types such as "Non-Disclosure Agreement", "Rental Agreement" or "Service Agreement" to every account, and a custom type that duplicates one of them splits the account's documents across two types. Create a new type only when none of the existing ones fits. Write `name` in Title Case, the way fynk's own types are named ("Data Processing Agreement", "Letter of Intent"), rather than copying the user's phrasing verbatim - a request for "a type for supplier framework contracts" should produce "Supplier Framework Agreement". `description` and `prompt` are how a new type is normally set up, so propose both from what the type is for rather than leaving them out: - `description` tells users what the type covers, in one sentence. fynk's "Rental Agreement" reads: "A contract between a landlord and tenant defining the terms under which property is rented, including duration, payment terms, and usage conditions." - `prompt` is what fynk's AI analyses read when deciding whether a document is of this type - without one, they rarely pick the type. Phrase it as a selection criterion, the way fynk's own types do. "Rental Agreement" reads: "Select this type if the document defines the terms under which a tenant rents property from a landlord, including rent amount, duration, deposit, and usage conditions." `relevant_metadata_uuids` decides which metadata fields fynk's AI analyses look for in documents of this type, besides the fields already relevant for every document type, which apply to the new type automatically. Call list-account-metadata to find the candidates, and propose the fields that type's documents would carry, e.g. a "Net Rent" field for a lease type. The fields chosen here are made relevant for the new type alongside the types they already have, and list-account-metadata reports the result: each field there names the document types it is relevant for.
create-account-document-type
Create a new account-level metadata field definition. Use this tool when: - The user asks for a new metadata field to track some piece of information on their documents - You need a metadata field to exist before writing values to it with update-document-metadata-values Call list-account-metadata first: the account may already have a field for what the user wants, and fynk provides a range of system metadata fields that cannot be re-created under the same name. `name` is the programmatic identifier (lowercase letters, digits and underscores only) and `display_name` is what the user sees. Write `display_name` in Title Case, the way fynk's own fields are named ("Signing Date", "Contract Value"), rather than copying the user's phrasing verbatim - a request for "a product colour metadata" should still produce `product_colour` / "Product Colour". `select` and `multi_select` fields require `select_values` (the allowed options); no other field type accepts them. These strings are literally what the user picks from in the UI, so write them as presentable labels, capitalised like `display_name`: "Red", "Green", "Blue", not the "red, green or blue" lifted out of the request. `name` and `value_type` are fixed at creation and cannot be changed afterwards, and it is worth getting the rest right first time rather than leaving a correction to make later. So confirm any detail the user has not spelled out instead of guessing at it - in particular the exact `select_values` strings, since a request like "a colour field with red, green or blue" names the options without settling how they should read. `prompt` and `keywords` decide whether fynk's AI analyses fill this field in - a `prompt` puts the field into them, `keywords` only assist it and do nothing on their own. This is how a new field is normally set up: fynk's own creation form turns AI analysis on by default and requires both. So propose a `prompt` and `keywords` drawn from what the field is for rather than silently leaving them out, and omit both only for a field the user wants to fill in by hand. Set a `description` as well - it is what tells a user configuring the field what it holds.
create-account-metadata
Create one or more account parties saved in your account. Use this tool when: - The user asks to add their company, a subsidiary, a group company or a parent company as parties of the account - A document or template needs an account party (account_party_uuid) that list-account-parties does not return yet Account parties are the account's own entities — the user's company, subsidiaries, group companies or parent company. They are the internal side of an agreement and are reusable across multiple documents and templates. Never use this tool for counterparties. Add external parties to the relevant document or template with create-document-party or create-template-party. Create up to 20 parties per call. Before calling this tool, call list-account-parties to check which parties already exist. Only include parties that are missing; do not create duplicates of existing account parties. The parties are created together or not at all. Accounts whose plan does not include multiple account parties may only hold one; a call that would take such an account past one party is refused with a permission error and creates nothing.
create-account-parties
Create a new tag in the current account. Use this tool when: - The user asks to create a new tag - You need a new tag to be available before attaching it to documents or templates `name` (max 40 chars) and `color` (hex like "#FF0000") are required.
create-account-tag
Create a new team in the current account. Use this tool when: - The user asks to create a new team - You need a new team to be available before attaching it to documents or templates The tool requires `name`. Do not ask the user about an icon — the team will use the default icon. Optionally pass `account_user_uuids` to add initial members. After creation, don't expose the UUID to the user.
create-account-team
Create a signed URL that a single PDF can be POST-uploaded to, for later use with create-document-from-pdf-upload. Use this tool when: - The user wants to create a document from an existing PDF file and you need somewhere to upload it to first Returns a `uuid` (pass it to create-document-from-pdf-upload after the upload completes), a `url` (target of the POST request), a `fields` map to send as form fields in the POST body before the file itself, and an `expires_at` timestamp after which the URL stops working.
create-document-pdf-upload-url
Create a new document from a PDF previously uploaded via create-document-pdf-upload-url. Use this tool when: - The user wants to import an existing PDF into fynk as a draft document for further processing, OR - The user wants to record an already-signed PDF in fynk by setting initial_stage to "done" Call create-document-pdf-upload-url first to obtain `file_upload_uuid`, then upload the PDF to the URL it returns with a multipart/form-data POST, as that tool describes, before calling this tool. `initial_stage` is required and must be either "draft" or "done"; ask the user which they want if it isn't clear from context. Depending on the account's settings, `template_uuid` may be required (it copies checkpoints, document type, metadata, parties, etc. from a template). Only pass `auto_apply_ai_analysis` when the user has expressed whether AI analysis results should be applied to the document automatically; omit it to use the account's default setting. The AI analysis runs in the background after this tool returns; read its state from the ai_analysis section of get-document-info before relying on the parties, metadata or summary it fills in. The `team_uuids`, `tag_uuids`, and `account_party_uuid` arguments expect UUIDs, which can be discovered via list-account-teams, list-account-tags, and list-account-parties respectively.
create-document-from-pdf-upload
Create a new, empty document from scratch (not based on a template), optionally assigning teams, tags, and an account party. Use this tool when: - The user wants to start a new blank document that is not based on a template The document is created in the draft stage with no content. To create a document based on a template instead, use create-document-from-template. The `team_uuids`, `tag_uuids`, and `account_party_uuid` arguments expect UUIDs, which can be discovered via list-account-teams, list-account-tags, and list-account-parties respectively.
create-document-from-scratch
Create a new document from a template, optionally pre-filling parties, signatories, and dynamic fields, and optionally starting the signing process immediately. Use this tool when: - The user wants to generate a document based on an existing template It is usually helpful to call get-template-info with include=["parties", "signatories", "dynamic_fields"] first to discover the template's parties, signatories, and dynamic fields so that the `parties`, `signatories`, and `dynamic_field_values` arguments can be populated correctly. When completing dynamic fields, take note of the field's `type` when constructing the value. These are the rules to use when constructing the `value` string: - number: the numeric value in a string, using '.' as the decimal separator -> "1234.56" - currency: concatenate the ISO currency code and the numeric value with a ';' -> "EUR;1000.10" (for one thousand Euro and ten cents) - currency_duration: same as currency, but append another ';' followed by either `monthly` or `yearly` -> "EUR;1000.10;monthly" / "USD;1000.10;yearly" - select: one of the options from the field's `select_values` list -> "red" - multi_select: an array of the selected values in the `values` field -> ["red", "blue"] - bool: either of the strings "true" (displayed to the user as "Yes") or "false" (displayed to the user as "No") -> "true" / "false" - duration: a PHP-compatible duration specification -> "P6D" (6 days), "P2W" (2 weeks), "PT12H" (12 hours) - date: the date in the format "YYYY-MM-DD" -> "2026-12-31" - email, text, textarea, or any type not listed above: a string -> "test@example.com" Setting `start_signing=true` will move the new document straight into the signing stage and invite the signatories to sign it; this fails if any required information (party data, mandatory dynamic field values, signature blocks) is missing.
create-document-from-template
Links two existing documents, recording how they relate to each other, e.g. that one contract is a renewal of another. Use this tool when: - The user says how two contracts relate, e.g. "this is the renewal of the 2023 service agreement" or "link the amendment to its main contract" - Documents migrated from another system belong together, e.g. a framework agreement and the order forms under it (parent_of / child_of) relationship_type is read from document_uuid's side: renewal_of means document_uuid renews other_document_uuid, renewed_by means other_document_uuid renews document_uuid. Find both documents' UUIDs with list-documents first. Two documents can be linked only once with each kind of relationship. The documents already linked to a document are returned by get-document-info with include linked_documents. To change a link's relationship type, remove the link with delete-document-link and create the right one.
create-document-link
Adds a party to a document, alongside any parties it already has. Use this tool when: - A contracting party is missing from a document, e.g. the counterparty of a contract created from scratch - A signatory has to be added for a party the document does not have yet: create the party first, then add the signatory with create-document-signatory Pass party_account_party_uuid to add one of the account's saved parties (list-account-parties), usually the user's own company. A saved party can be on a document only once, and is always internal. For any other party, give party_entity_name, party_address and party_scope instead. Parties cannot be added while the document is archived, in the signing stage or an approved stage, going through an approval checkpoint, or bound by a preemptive signature.
create-document-party
Adds a signatory to a document. Use this tool when: - You have a document with one or more parties configured and want to add a signatory for one of the parties. The signatory becomes a user of the document and is invited by email to sign it once the document moves to the signing stage, so confirm the email address with the user rather than inferring it. The email may belong to someone who is already a user of the document, e.g. one added with create-document-user; they become a signatory and keep their role. When adding a signatory whose email corresponds to an existing user in the current fynk account, all of the optional arguments will be ignored and the signatory information will be populated from the existing user's profile.
create-document-signatory
Gives a person access to a document as an owner, collaborator or viewer, and by default emails them an invitation. Use this tool when: - Someone should be able to open, comment on or edit a document, e.g. a colleague who should review a draft or a counterparty's lawyer who should comment during review - A colleague should become an owner of a document Identify the person by exactly one of `email` or `account_user_uuid`. Someone who is to sign the document is added with create-document-signatory instead. An email address that already belongs to a user of the document is refused; change that user with update-document-user. By default the person is emailed an invitation straight away. Before calling, always ask the user whether the person should receive that email now, rather than relying on the default, and confirm the email address with them rather than inferring it. With `invite_method` none the person is added without an email, and can be invited later via update-document-user with `mode` send_invitation. A person without a fynk account user in this account can open the document only once invited. When creating multiple users in succession, make sure to check with the user for each of them whether an email should be sent. Whenever the document has a party on the person's side, `party_identifier` is required. Any of the document's parties is accepted, but the person usually belongs to one on their side: a party where is_internal is true for a person with a fynk account user in this account, one where is_internal is false for anyone else, typically the counterparty their company is. Ask the user which party if it is not clear. A person without a fynk account user in this account (internal_user false) cannot be added while the document is in the draft or approved_draft stage, and cannot be an owner. For a person with a fynk account user in this account, the name and title come from their fynk profile, and `first_name`, `last_name` and `title` are ignored.
create-document-user
Create a new dynamic field on a template. Use this tool when: - The user wants to add a variable / fill-in field (e.g. text, number, date, select) to a template - You are building up a template and need a placeholder whose value is filled in per document IMPORTANT: this is only the first of two steps. Creating the field does NOT place it in the template content, so on its own the fill-in placeholder will not appear in the document text. To make it show up, reference the returned `ref_uuid` in the template body (via replace-template-content) as: <span data-dynamic-field data-ref-uuid="<dynamic field ref_uuid>"></span> Until it is referenced in the content the field exists but is rendered nowhere. The same two-step pattern applies to signature blocks (create-template-signature-block, then `<div data-signatures><span data-signature-block data-ref-uuid="..."></span></div>`). Dynamic fields define the variable data filled in when a template is used to create a document. Each field has a `type` controlling what values it accepts, and a `scope` controlling who fills it in. A party's name or address is never a dynamic field. Both live on the party record: add the party with create-template-party and render its details in the content with <span data-party data-ref-uuid="..." data-format="name"></span>, taking data-format="address" for the address as a block and data-format="address:inline" for it on one line, as a preamble reads it. A document made from the template then follows its own parties. `select` and `multi_select` fields require `select_values` (the allowed options). The optional default value is set via `value` (for non-multi_select fields) or `values` (for multi_select fields). Construct the `value` string according to the field `type`: - number: the numeric value in a string, using '.' as the decimal separator -> "1234.56" - currency: concatenate the ISO currency code and the numeric value with a ';' -> "EUR;1000.10" - currency_duration: same as currency, but append another ';' followed by either `monthly` or `yearly` -> "EUR;1000.10;monthly" - select: one of the options from `select_values` -> "red" - multi_select: an array of the selected options in the `values` field -> ["red", "blue"] - bool: either of the strings "true" (shown as "Yes") or "false" (shown as "No") - duration: a PHP-compatible duration specification -> "P6D" (6 days) - date: the date in the format "YYYY-MM-DD" -> "2026-12-31" - email, text, textarea, or any type not listed above: a string -> "test@example.com"
create-template-dynamic-field
Create a new empty template with editable ProseMirror content. Use this tool when: - The user wants to start building a new template from scratch (not from an existing PDF or template) The new template is created empty and its content is authored in a later step. The body references parties, dynamic fields and signature blocks by ref_uuid, so those have to exist before the content can point at them. Build the template in this order: 1. create-template-party for each contracting party. 2. create-template-signature-block for each party that signs. 3. create-template-dynamic-field for every value that varies per document - dates, amounts, notice periods, payment terms. A party's name or address is never one of them: both live on the party record and the content renders them from there. 4. replace-template-content once, with a body that references all of them by their ref_uuids and wraps each clause in an ordered list node so fynk numbers it. Authoring the content first and adding the parties, fields and signature blocks afterwards forces a second, destructive rewrite of the whole body to weave the references in, so plan them up front. This applies just as much when the content is derived from a source document such as a PDF: every filled-in blank in the source is a dynamic field unless it holds party identity, and its signature lines are signature blocks. The `locale` defines the template's content language and default number formats. Never ask the user for it - a BCP 47 tag is not something they can be expected to know. Infer it from the conversation, e.g. the language the content is to be written in or a country or jurisdiction the user names, and otherwise omit it, which falls back to the account's locale.
create-template-from-scratch
Add a party to a template. Use this tool when: - The user wants to add a party (e.g. a counterparty, customer, or employer) to a template - You are building up a template and need parties before adding signatories or signature blocks There are two ways to add a party: - Internal (saved) party: send `account_party_uuid` (from list-account-parties) together with `reference`. No other fields may be sent in this case. - External party: send `reference` and `scope`, and optionally `entity_name` and `address`. The two names on a party say different things: - `reference` is the generic label for the party's role on the template (e.g. "Employer", "Customer"), and stays the same for every document made from it. - `entity_name` is the name of the legal entity itself: a company's name ("Acme GmbH") or, when the party is an individual rather than an organisation, that person's name. On a template it is usually only known for the account's own side; a counterparty's is filled in per document, so leave it out rather than inventing one. To render the party's details inline in the template text, reference the returned `ref_uuid` in the body (via replace-template-content) as: <span data-party data-ref-uuid="<party ref_uuid>" data-format="name"></span> where `data-format` selects what is rendered: "name" (the party's entity/company name), "reference" (its reference label), "address", or "address:inline". A data-format is required. Note: adding a party does not, by itself, give that party anywhere to sign. If the party is meant to sign documents created from the template, follow up with create-template-signature-block for the party — and remember that the signature block must in turn be placed in the template content (via replace-template-content) inside a signature container, `<div data-signatures><span data-signature-block data-ref-uuid="..."></span></div>`, before it will appear on any document.
create-template-party
Add a signature block to a template, bound either to one of its parties or to a single signatory. Use this tool when: - The user wants a party to have a place to sign on documents created from the template - The user wants one specific signatory to have their own place to sign - You are building up a template and need to add signing slots Pass exactly one of `party_uuid` or `document_user_uuid`. A party-bound block is signed by every signatory of that party, whoever they turn out to be on a document created from the template; a user-bound block is signed only by the signatory it names. Use get-template-info with include=["parties", "signatories"] to discover the available parties and signatories and their UUIDs. A user-bound block requires a signatory that belongs to a party, because the block records that party alongside the signatory. IMPORTANT: this is only the first of two steps. Creating the signature block does NOT place it in the template content, so on its own it will not appear on any document. To make it show up, reference the returned `ref_uuid` in the template body (via replace-template-content) from a signature container, which houses one or more blocks: <div data-signatures data-align="left"><span data-signature-block data-ref-uuid="<signature block ref_uuid>"></span></div> A block is always placed inside such a container, even when it is the only one. Until it is referenced in the content the block exists but is rendered nowhere. The same two-step pattern applies to dynamic fields (create-template-dynamic-field, then `<span data-dynamic-field data-ref-uuid="...">`). `style` (regular or minimal) and `scale` (50–150, percent) are optional and default to "regular" and 100.
create-template-signature-block
Remove a document type from the account, whether it is one of the account's own types or one of fynk's system document types. Use this tool when: - The user explicitly asks to delete or remove a document type `document_type_uuid` comes from list-account-document-types, and the user must have made clear which type they mean - either by naming it, or because it is the type this conversation has been about. Ask which one they mean when that is not clear, offering the candidates by name. What removing a type does depends on what list-account-document-types reports for it. A type the account created itself, without `provided_by_fynk`, is deleted for good. One of fynk's own types, with `provided_by_fynk`, is deactivated instead: it disappears from the account but can be brought back as fynk provides it with update-account-document-type and `reactivate: true`. A `customised` type loses its customisation either way, so tell the user so before going ahead with one. A type that documents or templates still use cannot be removed. The refusal says how many use it.
delete-account-document-type
Delete one of the account's own metadata field definitions. Use this tool when: - The user explicitly asks to delete a metadata field `metadata_uuid` comes from list-account-metadata, and the user must have made clear which field they mean - either by naming it, or because it is the field this conversation has been about. Ask which one they mean when that is not clear, offering the candidates by their display name. Deleting a field also removes every value recorded for it, on every document and template in the account, and none of that can be brought back. So deleting a field the account has recorded values for is refused until the user has confirmed it: the refusal names the field and how many documents and templates hold a value for it - then repeat the call with `confirmed_deleting_values_in_use: true` once they have confirmed it. Send that only in answer to such a refusal, never as a matter of course. Put the effect to the user in their own terms and ask before going ahead - "deleting Discount Rate would also remove the value 12 documents hold for it, shall I go ahead?" - rather than quoting the refusal back at them. Name the field you are about to delete either way, and never delete more than the user asked for. Where the user wants a field to stop being filled in rather than to lose what it already holds, clear its `prompt` with update-account-metadata instead: that takes the field out of fynk's AI analyses and leaves the values on their documents alone. Only the account's own fields can be deleted. fynk's system fields are provided to every account and cannot be removed, `system_reference` fields included - use update-account-metadata to change how one of those is configured for this account. Deletion is refused while a bulk metadata operation is still running for the field.
delete-account-metadata
Delete an existing tag. Use this tool when: - The user explicitly asks to delete a tag The specified tag is deleted and detached from documents and templates automatically.
delete-account-tag
Delete an existing team. Use this tool when: - The user explicitly asks to delete a team The specified team is deleted and detached from documents and templates automatically. Deletion will fail if the team is assigned as an approver on any template.
delete-account-team
Removes a link between two documents. Both documents stay as they are; only the recorded relationship between them goes. Use this tool when: - A link was made in error, e.g. the wrong contract was marked as the one renewed, or the relationship type was wrong (remove it, then create the right one with create-document-link) - The user says two documents no longer belong together Take link_uuid from the linked_documents section of get-document-info for document_uuid.
delete-document-link
Remove a signatory from a document. Use this tool when: - A signatory was added in error or should no longer sign and the document has not yet been signed by them Identify the signatory to remove by `document_uuid` plus `signatory_email`. Removal may fail if the document's stage no longer permits signatory changes. A signatory who is also an owner or collaborator (their role in the document_users section of get-document-info) keeps that access and only stops being a signatory. A signatory whose role is viewer is removed from the document entirely and loses access to it; tell the user this before removing them.
delete-document-signatory
Removes a user from a document entirely, revoking their access to it. Use this tool when: - Someone should no longer have access to a document, e.g. a collaborator who has left the project - A user was added to a document by mistake Identify the user by `document_uuid` plus `email`; the document_users section of get-document-info lists everyone with access. This also removes the user as a signatory, if they are one. To only stop an owner or collaborator from signing, use delete-document-signatory instead. A document always keeps at least one owner, so removing its last owner is refused. Removing yourself ends your own access to the document.
delete-document-user
Delete a dynamic field from a template. Use this tool when: - The user explicitly asks to remove a dynamic field (a variable / fill-in field) from a template A dynamic field cannot be deleted while it is referenced by a condition or a metadata value on the template; remove those references first. Use get-template-info with include=["dynamic_fields"] to discover the dynamic fields on a template and their UUIDs.
delete-template-dynamic-field
Delete a party from a template. Use this tool when: - The user explicitly asks to remove a party from a template A party cannot be deleted while it still has signature blocks bound to it. Delete those signature blocks first with delete-template-signature-block. Use get-template-info to discover the parties on a template and their UUIDs.
delete-template-party
Delete a signature block from a template. Use this tool when: - The user explicitly asks to remove a signature block (a party's signing slot) from a template The party the signature block belonged to remains on the template; only the signing slot is removed. Use get-template-info with include=["signature_blocks"] to discover the signature blocks on a template and their UUIDs.
delete-template-signature-block
Remove one or more account users from a team. Use this tool when: - The user asks to remove people from a team Only the account users listed in `account_user_uuids` are removed; other team members stay attached. Passing a user that is not on the team is a no-op.
detach-account-users-from-team
Create a new draft document as a copy of an existing document. Use this tool when: - The user wants to duplicate or copy a document, e.g. to reuse a previous contract as the starting point for a new one with a different counterparty - A new agreement should start from an existing document rather than from a template The copy takes over the source document's content, parties, signatories, dynamic field values, metadata values, attachments, teams, tags, document type and template link. The new document always starts in the draft stage, whatever stage the source document is in, and a source document that is in signing or done is copied with its content as it was before signing started. Change what differs in the new document afterwards with the update-* tools, e.g. update-document-party for the counterparty or update-document-dynamic-fields for amounts and dates.
duplicate-document
Create a new template as a copy of an existing template. Use this tool when: - The user wants to duplicate or copy a template, e.g. to build a variant of an existing contract for another jurisdiction or business line - A new template should start from an existing one rather than from scratch The copy takes over the source template's content, parties, signatories, signature blocks, dynamic fields, conditions, metadata values, attachments, teams, tags, document type, locale and published state. Documents already created from the source template stay linked to the source. Change what differs in the new template afterwards with the template tools, e.g. update-template-party, update-template-dynamic-field or replace-template-content. replace-template-content only writes a draft, so a copy of a published template has to be unpublished with set-template-published-state before its body can be rewritten.
duplicate-template
Get information about the current fynk account. Use this tool when: - You need details about the active account (e.g. default document locale, signature settings) before tailoring a response - You are tailoring guidance to the account's business, and need what it reported about itself when signing up (industry, company size, the department the person who signed up works in) For information about the current user, use get-user-info
get-account-info
Gets information about a document. Use this tool when: - You have a document's UUID and want to know more details about it. e.g. who is signing it, what values its dynamic fields or metadata have, etc - You need the documents linked to a document, e.g. the contract it renews or the amendments made to it (include linked_documents) Called with no include parameter, returns the document's parties, teams, details, signatories, signing settings and workflow state. Use include to name the sections you want instead - among them dynamic_fields, conditions, linked_documents, metadata_values, signature_blocks, summary_text, tags, timestamps, attachments, stored_files, document_users and ai_analysis - and the response carries exactly those, so a question about one aspect of a document costs one section rather than the whole document. The document_users section lists everyone with access to the document, signatories included, each with their access level (owner, collaborator or viewer) and whether they have been invited, plus the text fynk adds to invitation emails to people outside the account. Use it to answer questions like "who has access to this document?" or "has Emily been invited yet?". The stored_files section holds what the app shows as "Internal file storage", separate from attachments: call them that when talking to the user, never "stored files". The ai_analysis section reports the state of the AI analysis that creating a document from a PDF starts in the background. Request it after creating a document from a PDF and before relying on the document's parties, metadata or summary: until its status is applied, they do not carry the analysis results. This tool covers a single document. Whenever possible avoid calling it once per document to gather the same information about several documents: list-documents returns parties, teams, tags and timestamps for a whole list via its include parameter, and specific metadata values for a whole list via its include_metadata parameter. It can be restricted to the UUIDs you already have, to get exactly the documents you are interested in. The default response lists both the document's parties (the contracting entities, frequently organizations) and its signatories (the individual people who sign). These are distinct: a person often signs on behalf of a party (e.g. a business) without appearing as a party, so consider the signatories — not just the parties — when answering whether a specific named person is involved in or signs a document. The dynamic_field_visibility argument narrows the dynamic_fields section to the fields that appear in the document itself, or to the ones that do not. A field belonging to a document is not necessarily written into it: fields get added and then never placed in the text, or the passage that referred to one gets rewritten, leaving a value no reader ever sees. Not every not_visible field is idle, though. Some exist only to drive a condition deciding which clauses the document shows, so they shape the contract without appearing in it (you can use the "conditions" include option to see which fields drive which conditions). Others sit inside a passage that a currently inactive condition removes, so they would appear if that condition flipped. Use "visible" when the question is about what the contract currently says. dynamic_field_visibility has no effect unless dynamic_fields is among the returned sections. The workflow_state object - in the response by default, and requestable via include alongside other sections - describes what can currently be done with the document: whether the signing process can be started at all, which stages the document can be moved on to and everything standing in the way of each of them (stage_transitions, whose blockers say why), whether the requesting user can start signing, and — when a checkpoint blocks progress — who still needs to approve. Use it to answer questions like "why can't I sign this yet?", "what is blocking this document?" or "who still has to sign?", answering with the full list rather than one problem at a time. It is technical state, not display content: relay it to the user as natural-language prose and never echo raw field names or snake_case values.
get-document-info
Get a download URL for the latest revision of a document as a PDF. Use this tool when: - The user wants to download the current state of a document as a PDF - You need a PDF link to share with the user for review Returns the URL as plain text. The URL is short-lived; fetch a new one if it expires before download.
get-latest-document-pdf-url
Returns the content of a template serialised as HTML. Use this tool when: - You want to read or navigate the content of a template - You want to understand the structure of a template before editing it The HTML uses semantic data-* attributes to represent fynk-specific nodes such as dynamic fields, party references, and signature blocks. Addressable nodes (paragraphs, headings, etc.) carry a data-uuid attribute that can be used to target individual nodes in subsequent operations. Clause numbering is dynamic. Numbered clauses are ordered list nodes — `<div data-list data-kind="ordered">` — that contain the clause text and, when nested, sub-clauses. Their computed number is shown read-only via a `data-number` attribute (e.g. `data-number="1.1."`). Numbers are never part of the text; do not treat them as editable content. A cross-reference to a clause appears as `<span data-section-ref data-uuid="...">`, where data-uuid is the data-uuid of the list node it points at. It is empty: what it renders is that clause's computed number, so it follows the clause rather than stating a number of its own. Dynamic fields (fill-in placeholders) appear inline as `<span data-dynamic-field data-ref-uuid="...">`, where data-ref-uuid is the field's ref_uuid (see get-template-info include=["dynamic_fields"]). Signature blocks are grouped in a signature container — `<div data-signatures data-align="..."><span data-signature-block data-ref-uuid="..."></span></div>` — where each `<span data-signature-block>` points at one block by its ref_uuid (see get-template-info include=["signature_blocks"]). Legacy content may still show a block outside any container, as `<div data-signature-block data-ref-uuid="...">`; writing it back turns it into a container holding that one block. Party references appear as `<span data-party data-ref-uuid="..." data-format="name|reference|address|address:inline">`, where data-format selects what is rendered (name = the party's entity_name, reference = its reference name). Images (`<img data-image>`), dynamic tables (`<div data-dynamic-table>`) and signing vote blocks (`<span data-signing-vote-block>`) appear as empty reference tags. Their contents are held outside the HTML and cannot be created or edited through it, so copy these tags over unchanged when rewriting the template; dropping one removes the image or table from the template. Text formatting - bold, colour, font, size, highlight - is stated inline, as the style of the tag carrying it. A block's layout is not: the margins, indent and line height a paragraph or heading is laid out with stay on the block itself, so the HTML says nothing about them. A block's alignment is stated, as `data-text-align` on the paragraph, heading or list node carrying it - left, center, right or justify - with a matching `text-align` style alongside it. A block carrying neither is aligned left. Only available for templates with a prosemirror_data content type. Returns an error for PDF templates.
get-template-html
Gets information about a template. Use this tool when: - You have a template's UUID and want to know more details about it. - e.g. when you want to create a document from the template and need to know which parties, dynamic fields, etc are available in the template. Called with no include parameter, returns the template's identity, its parties, its teams, its description and its signing settings. Use include to name the sections you want instead - among them signatories, signature_blocks, dynamic_fields, conditions, metadata_values, tags, timestamps, attachments and stored_files - and the response carries exactly those, so a question about one aspect of a template costs one section rather than the whole template. The stored_files section holds what the app shows as "Internal file storage", separate from attachments: call them that when talking to the user, never "stored files".
get-template-info
Get information about the current user. Use this tool when: - You need to know who the current user is (email, locale, roles) before tailoring a response For information about the current fynk account, use get-account-info
get-user-info
Invite one or more people by email to join the current account as account users, or reactivate account users who were removed from the account, without sending an email. Use this tool when: - The user asks to invite colleagues, add new users or give people access to fynk - The user asks to resend an invitation to someone who has not accepted it yet, including one that has expired or was declined list-account-users with include ["invitations"] lists the invitations that have not been accepted or canceled, so check it when the user asks to resend invitations without naming the addresses. Batch invitations into one call for up to 25 people: inviting five colleagues is one call with five entries. The limit is 25 invitation entries per minute per calling user, across calls and including invitations the user sends from fynk's account settings. For more than 25 people, split the list into batches and wait for the rate limit to reset between batches. Ask the user which role to give when they have not said so. Resending an invitation also replaces its role and team assignment with the supplied values. Reactivation likewise replaces the previously removed account user's role and team membership. Omitting `team_uuids` or passing [] assigns no teams, clearing any previous assignment on resend or reactivation. Every entry is validated before processing begins, so one validation failure rejects the whole call and nothing is sent. An address that already belongs to an active account user is normally rejected during validation, and so is any invitation once the account has as many users as its plan includes. An invitation takes a seat only when it is accepted, so a call can send more invitations than the account has free seats; once the seats are taken, the remaining people cannot join until more seats are bought or someone is removed. Reactivating a removed account user takes a seat straight away, and a call reactivating more of them than there are free seats is rejected. list-account-users with include ["invitations"] returns the number of free seats as free_seats; when you invite more people than that, tell the user that not all of them will be able to join yet. The response lists one `outcome` per input entry, in input order: a sentence saying what was done for that address, e.g. "The existing account user was reactivated with the given role and teams. No email was sent." Tell the user what it says, since it is not always that an invitation was sent.
invite-account-users
Joins a document as a collaborator. If the current user is already an owner or collaborator on the document, they have already joined it: the tool returns their existing document user unchanged. Use this tool when: - You need to make changes to a document, but do not have a 'document user' in the document yet. - You need to make changes to a document, but your existing 'document user' does not yet have permission to change it. To join every document matching some conditions, find the ones you have not joined yet with list-documents; its description shows how to leave out the documents you have already joined.
join-document
Get a list of the document types available in the account (fynk's system-provided types plus any custom types defined for the account). Use this tool when: - You need a document type's UUID to filter list-documents by document type - You want to know which document types exist before referring to them by name in a response - You need to know what a document type covers, or how fynk's AI analyses recognise it (include=["details"]) Each document type is returned as its uuid and name by default. Request include=["details"] for its description and the prompt the AI analyses use to recognise it. Which metadata fields a document type has is reported from the other side, by list-account-metadata: each field there names the document types it is relevant for. By default, only the types the account currently offers are returned. Removing one of fynk's system types deactivates it rather than deleting it: set filter_state to "deactivated" to list those types (e.g. when the user wants to reactivate one) or to "all" to list them alongside the rest.
list-account-document-types
Get a list of the metadata fields available in the account to be associated with documents & templates. Use this tool when: - You need to know which metadata names exist before referencing them in get-document-info / list-documents - You want to know the type, allowed values, or other configuration of an account's metadata fields
list-account-metadata
Get a list of the account parties saved on your account. Account parties are the account's own entities — the user's company, subsidiaries, group companies or parent company. Phrasing like "our", "we", "us", "my company" or "our subsidiary" refers to an account party. These are the internal side of an agreement, as opposed to external parties (the counterparties on the other side), which you find with search-external-parties. Use this tool when: - You need to know which pre-defined parties are available for use in documents or templates - You need to provide an account_party_uuid (use a uuid from this tool's response) - You need an account party's UUID to filter list-documents by account party — e.g. to find documents involving "our" company or one of its subsidiaries If the entity is one of the account's own companies and is missing, use create-account-parties when available and needed for the user's request. If it is a counterparty, use search-external-parties. Absence from this list alone does not determine whether an entity is internal or external.
list-account-parties
Get a list of the playbooks defined in the account. Use this tool when: - You need a playbook's UUID to refer to it - You want to know which playbooks exist before referring to them by name in a response Playbooks allow automating the review of documents based on predefined criteria.
list-account-playbooks
Get a list of the tags available in the account to be associated with documents & templates. Use this tool when: - You need a tag's UUID to filter list-documents / list-templates by tag - You want to know which tags exist before referring to them by name in a response
list-account-tags
List the members (account users) of a given team. Use this tool when: - You need the account-user uuids of a team's members in order to add them to another team - The user asks who is in a team - You are merging or restructuring teams and need to know the current membership Returns each member's uuid, first_name, last_name, and email. Pass the uuids to attach-account-users-to-team to add the same people to another team. Suspended users are not included.
list-account-team-members
Get a list of the teams available in the account. Use this tool when: - You need a team's UUID to filter list-documents by team - You want to know which teams exist before referring to them by name in a response
list-account-teams
Get a list of the account users (the people who can log in to this fynk account), and optionally the invitations to join it that are still open. Use this tool when: - You need an account user's uuid, e.g. to add them to a team via attach-account-users-to-team - The user refers to a colleague by name and you need to match them to an account user - The user asks who is part of the account - The user asks who has been invited, who has not accepted yet, or whose invitation has expired or was declined: pass include ["invitations"] Returns each account user's uuid, first_name, last_name, and email. Only the account users the current user is allowed to see are returned: most users see everyone in the account, but 'limited manager's only see themselves and the members of their own teams. So this list is not necessarily the full set of people in the account - avoid presenting it as complete. The invitations are those not yet accepted or canceled, whether pending, expired or declined; someone who accepted is an account user instead. Only account users who may invite people can see them, and asking for them without that permission refuses the call. Alongside them comes free_seats, how many more people can join under the account's plan.
list-account-users
Get a paginated list of the documents available to the current user. Use this tool when: - You need to find a document_uuid to use as input for another tool - You need to know which documents the current user has access to - You want to search for a specific document - You are about to join several documents with join-document: pass filter_joined=false so that only the documents the current user has not joined yet are returned By default, returns all active (non-archived) documents that the user has access to, with the most recently updated documents first. sort_by and sort_direction arguments can be used to control the sorting. Archived documents are included or targeted using the filter_archived_state parameter. To keep responses small, each document is returned as a compact summary by default. Use the include parameter to request additional sections (parties, teams, tags, details, signing_settings, timestamps) when the user's question needs them, and prefer get-document-info when you need full information about a single document. When you need particular metadata values for several documents, name those fields in include_metadata and they are returned for every document in the response. Do not call get-document-info once per document to collect the same fields — one list-documents call with include_metadata answers the whole question. When you already have the UUIDs of the documents you care about, pass them as filter_document_uuids and combine that with include or include_metadata to gather information about exactly those documents in a single call. # Each account has its own vocabulary — discover it before filtering Accounts classify their documents using structures they define themselves: tags, document types, metadata fields (and their select options), teams and parties. The words a user puts in a question are usually the words their own account already uses as labels. "our customers", "suppliers", "key accounts", "renewals", "EMEA" and "high value" all sound like descriptions of content, but each is far more likely to be a tag, a document type, or a metadata field or option in this account. Tags in particular are the account's own free-form classification labels, commonly covering relationship type (customer, supplier, partner, reseller), commercial significance (key account, strategic), lifecycle or region. A plain category noun in a question very often corresponds to a tag rather than to anything in the document text — so check list-account-tags whenever a question groups documents into a category that isn't available as a document type. These lookups are cheap and return small, complete lists, so look rather than guess: - list-account-tags: the account's classification labels - list-account-document-types: e.g. NDA, MSA, Customer Agreement, DPA - list-account-metadata: field names, value types and select option values - list-account-teams / list-account-parties / search-external-parties: teams and contracting entities # Decompose the request, then map every part to a filter A question usually contains several independent conditions. Handle each one separately: 1. Split the request into its conditions. "what logo usage rights do we have for our largest customers?" is three: "logo usage rights", "largest", "customers". 2. For each condition, ask what kind of structured thing it could be: a tag, a document type, a metadata field or option, a party (account or external), a document user, a team, a template, an automation, an import, a stage, or an origin. 3. Look up the candidates with the companion tools above, then filter with the matching filter_ parameter. 4. Only leave a condition to filter_query once you have confirmed that no structured filter covers it. Finding a structured filter for one condition does NOT mean you are done — work through every condition before answering. In the example above, "largest" is a currency metadata field such as contract value (filter_metadata range, or sort_by that field), "customers" is very likely a tag or a document type, and "logo usage rights" may also be available from a metadata. Answering with just one of the three silently answers a different question than the user asked. # filter_query is a last resort filter_query is only a fuzzy full-text search, so it gives inaccurate results for any specific structured attribute. This holds even when the request is phrased loosely or topically ("documents about product variant Alpha", "anything to do with Acme") — topical phrasing does NOT mean the term is free-text rather than a structured field or value. Prefer filter_query only for genuinely free-text conditions, or when the user is clearly searching by document name. If filter_query returns no results, do not conclude that no matching documents exist before checking whether the search term corresponds to a tag, a document type, a metadata field or value, or a party. If it does, retry with the matching filter_ parameter instead. # Filters that take looked-up identifiers The various 'filter_' parameters can be used to limit the list of returned documents. Several filters take identifiers or names you can look up with companion tools: - filter_account_parties: list-account-parties - filter_external_parties: search-external-parties - filter_automations: search-automations - filter_document_types: list-account-document-types - filter_document_users: search-document-users - filter_imports: search-imports - filter_metadata (field names, types and option values): list-account-metadata - filter_tags / filter_excluded_tags: list-account-tags - filter_teams: list-account-teams - filter_templates: list-templates # Parties vs. people, and account vs. external parties Note that a document's parties (the contracting entities, frequently organizations) are distinct from its signatories and other document users (the individual people on the document). A named person commonly signs or is involved on behalf of a party without being a party themselves — so to find documents involving a specific person, use filter_document_users rather than a party filter. Parties also come in two kinds. Account parties are the account's OWN entities — the company the user belongs to and its subsidiaries, group or parent companies; phrasing like "our", "we", "us", "my company" or "our subsidiary" points to an account party (look them up with list-account-parties and filter with filter_account_parties). External parties are the counterparties on the other side of an agreement (look them up with search-external-parties and filter with filter_external_parties). When it is not clear which kind a named entity is, or when one lookup returns nothing, check the other kind before concluding that no matching party or documents exist. # Active vs. archived documents Only active — i.e. not archived — documents are returned by default, so a default call silently leaves archived documents out of the answer. Archiving is not deletion: an archived document still exists, and for questions about past, completed or superseded contracts it may be the document being asked about. - Set filter_archived_state=all whenever the answer is meant to cover a complete set or a count — "all our NDAs", "how many contracts do we have with Acme", "which suppliers have we signed with", "what is our total contract value". A default call answers such a question with a number that is too low, and nothing in the response reveals that. - Set filter_archived_state=archived only when the user asks specifically about archived documents. - If a call returns no results, retry with filter_archived_state=all before concluding that no matching documents exist — alongside the other checks above, i.e. whether a term you passed to filter_query is really a tag, document type, metadata field or party, and whether a named entity is the other kind of party. When an answer draws on results that include archived documents, say which ones are archived. Request include=["timestamps"] to see this: archived_at is set on archived documents and null on active ones.
list-documents
Get a paginated list of the templates available to the current user. Use this tool when: - You need to know which templates are available for creating documents from - You need to know which templates the user may edit in fynk. These will have a "url" field pointing to the edit page. No "url" means no permission to edit By default, returns all active (non-archived) templates that the user has access to, with the most recently updated templates first. sort_by and sort_direction arguments can be used to control the sorting. To keep responses small, each template is returned as a compact summary by default. Use the include parameter to request additional sections (parties, teams, tags, details, signing_settings, timestamps) when the user's question needs them, and prefer get-template-info when you need full information about a single template. The various 'filter_' arguments can be used to limit the list of returned templates. # Active vs. archived templates Only active — i.e. not archived — templates are returned by default. Archiving is not deletion: an archived template still exists and its past documents still reference it. Set filter_archived_state=all when the answer is meant to cover every template the account has, and retry with it if a call returns no results, before concluding that no matching template exists. Set filter_archived_state=archived only when the user asks specifically about archived templates. When picking a template to create a new document from, keep the default: an archived template is one the account has retired from use. A response only reveals which templates are archived if you request include=["timestamps"], which carries archived_at.
list-templates
fynk ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve fynk's ChatGPT Plugin discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
What are fynk alternatives on ChatGPT?
As of 2026-11-15, fynk competes with AuditTrove, Avvoka, ClauseAI, Contracko, Contract Information Extractor, Definely, DocDraft, DUE Brand Deal Commercials and 9 more in ChatGPT Contract Lifecycle & Review, ranked by public Discoverability Score.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.


