What's new

Sharing a contract with another team used to mean adding its members one at a time, on every contract. The share field on a contract’s Access tab now searches groups as well as people. Pick a group and Pactly shows who will gain access before you confirm, leaving out anyone who can already open the contract.

Each member gets an individual share, so they appear under Shared with and can be removed one by one. Membership is read at the moment you confirm. Someone who joins the group later does not gain access, and someone who leaves keeps theirs until you remove them.

Bulk sharing: Select contracts in the Contracts list and choose Share with group from the bulk actions. Pactly previews the result before you confirm, and each person receives one email listing every contract they gained.

Notify people with Shared Access: Workflow Notify actions have a new recipient option, Users with Shared Access. It is resolved when the action runs, so it reaches whoever the contract is shared with at that moment, and anyone also covered by another recipient role receives a single email.

The download and share guide walks through sharing.

Projects could only export to Excel, which carries the values but loses the colour pills, checklist badges and column widths that make the grid easy to scan. You can now export a Project as a PDF that looks like the grid on screen, ready to file as a fixed review record.

Choose PDF in the export dialog, then pick A4 or A3 and portrait or landscape. Saved column widths are kept. When the grid is wider than the page, Pactly splits it into column groups on separate pages and repeats the Contract column and the headers on each one. Yes/No columns print in a compact width to save space.

PDF export handles Projects of up to 20,000 result cells. Excel export is unchanged, keeps its AI reasoning and source reference options, and has no size limit. The export guide covers exporting from a Project.

Word comments and tracked changes used to pass through finalization untouched, then show up in the summary and approval views that follow. When you finalize a Word document that still contains either, Pactly now asks what to do with them. Delete comments and Accept all tracked changes are separate choices, both start unchecked, and only the ones relevant to the document appear. A clean document finalizes without the extra step.

Cleanup applies to the finalized copy only. Earlier versions stay as they were, and in the Word add-in your open document is left alone. Anything you keep stays in the document through approval.

Comments hidden in the viewer: The document viewer now hides Word comments until you click the comments button beside search. Hiding changes the view only and removes nothing from the document.

Before signing: Pactly E-Signatures warns you when the document still contains comments or tracked changes, then removes them from the signing PDF as before. Review the PDF before sending.

The finalization guide covers the cleanup step.

Resume an unfinished request: Closing the signing dialog or reloading the page used to lose your recipients and placed fields. Pactly now keeps that preparation in the same browser for up to 24 hours. An orange dot on Sign marks the unfinished setup, and Resume unfinished signature brings it back. Resuming never sends invitations by itself.

Send PDFs that arrive already signed or sealed: When a counterparty signs in their own e-signature tool and sends the file over, that PDF is often locked by the tool that produced it, and Pactly used to refuse it. Pactly now adds your signature as a new revision and leaves everything the earlier signature covers untouched. Where the author certified the file or restricted further signing, Pactly tells you what Adobe Acrobat will report afterwards and lets you decide whether to sign anyway. PDFs that need a password to open are still refused.

The signature request guide covers sending and resuming a request.

The public API now covers enough of Pactly for an integration or an AI agent to do real contract work. Until now, a caller could read a contract it already had the ID for. It can now find one: GET /v1/contracts takes filters for keyword, status, type, party, owner, category, dates and renewal state, with cursor pagination for walking large result sets.

Seven new endpoints open up the rest. /v1/parties and /v1/party-attributes return your contact book, including each party’s sanctions screening status. /v1/clauses and /v1/playbooks expose your standards library, and POST /v1/playbooks/{id}/match checks a document against a playbook’s keyword rules to show which positions it touches.

Every endpoint, filter and scope is documented on the API reference.

Long email threads used to pile duplicate attachments onto a contract: every reply in a thread carries the same files again, and each one was re-added to the Attachments panel. Pactly’s own notification emails made it worse, since they include the request’s files and land back in the contract’s email-in address.

That’s fixed at the source. Attachment extraction now skips Pactly-generated emails entirely, and every path that adds attachments (email-in, form submissions, e-signature flows, notes) skips files that are byte-identical to one already on the contract. Adding a duplicate manually shows a warning instead of silently doing nothing. A changed version of a document still comes through as its own attachment.

Cleaning up existing duplicates: The Attachments panel now groups identical copies into a single entry with a count badge. Expand a group to see each copy’s date and where it came from, then click the copies you don’t need (shift-click selects a range) and delete them in one bulk action.

The email-in guide covers how attachments arrive by email.

Forms evolve, and questions get removed. Previously, deleting a question also removed its answers from every entry, including entries submitted long before the change. That data is now preserved: entries keep showing answers to removed questions in the entry view, the PDF download and the print view.

Each one carries a Removed badge with a note explaining whether the answer was given before or after the question was removed. Removed questions are read-only, so old answers can’t be edited into a form that no longer asks them.

There’s also a new guard rail: the delete dialog now tells you how many entries have already answered a question before you remove it, so you know exactly what a form change touches. See the form building guide for managing fields.

Until now, a file added to a Pactly E-Signatures request could only ride along in the recipient’s email. If an annex, schedule or exhibit had to be inside the executed document, you pasted it into the contract by hand or used a third-party provider. You can now add those files to the signing request itself. They are combined with the contract into a single PDF, and that is what every recipient signs.

Two ways to add a file, kept distinct: Documents added under Additional documents in the signing panel are merged into the signed PDF, so the signing page renders them, the executed document contains them, and the audit report covers them. Files attached on a recipient’s row still go out with that recipient’s email only and stay out of the signed document, which is the right choice for a reference document you do not want signed. The review step before sending lists which files are being signed and which are emailed only.

Fields on merged pages: Field placement now knows about the merged pages, so you can place signature and form fields on an annex the same way you place them on the contract. Drag the documents into the order you want them to appear before you send. The signature request guide walks through the full send flow.

In July, documents signed with Pactly E-Signatures gained an Adobe-trusted seal. This release finishes the job. Every seal now includes a timestamp from a trusted time-stamping authority, so the signing time no longer depends on anyone’s computer clock, and the PDF embeds the certificate and revocation data a validator needs. Acrobat reports the signature as LTV enabled: it will still verify years from now, after the signing certificate itself has expired.

Earlier signatures stay valid: If a counterparty signed the document elsewhere before it reached Pactly, the Pactly seal is now applied as an append-only update, leaving every byte the earlier signature covers untouched. Both signatures validate side by side instead of the earlier one being reported as altered.

A cleaner verification panel: Signature blocks and completion dates are now drawn into the page itself rather than layered on as annotations, which removes the “Annotations Modified” warning Acrobat used to show on Pactly-signed PDFs. A document that arrives already signed keeps the earlier approach so that signature is never disturbed.

As before, only a cryptographic fingerprint of the document is used to produce the seal. The document itself never leaves Pactly’s infrastructure. How the seal works and how to verify it are covered in the signature validity guide.

Configurable signing link expiry: Signing links used to stop working after 30 days with no way to change it, while reminder schedules could carry on well past that point. Administrators can now set how long a link stays valid, from 30 to 120 days, on the Pactly E-Signatures settings page. The default is now 60 days. Reminder schedules are bound to that window, the settings page previews the schedule against it, and no reminder goes out for a link that has already expired. Each request keeps the expiry it was sent with, and every email about a request now carries the same link. Reminder schedules are covered in the signature reminders guide.

Sign from the timeline: If you are one of the signers and already logged in to Pactly, the Out for Signing event on the contract timeline now shows a Sign contract button on your row. You go straight to the signing view without digging for the email.

Import a folder: The bulk importer now takes folders as well as files. Choose Add folder or drop a folder onto the import area, and Pactly walks every subfolder and lines up the PDF and Word files it finds in the staging table, with the same per-file checks as before. A historical archive organised by year or by counterparty no longer has to be opened one folder at a time.

Import as Archived: Old archives are mostly expired or inactive agreements. A new Import as control, available per row and in the bulk-apply bar, lets you land those contracts as Archived instead of Executed, so a backfill does not clutter the active repository and you do not archive hundreds of contracts by hand afterwards. AI classification, renaming and reference year handling work the same either way, and the archive is recorded on each contract’s timeline.

The staging queue holds up to 500 files per import, and Pactly tells you when files were skipped so nothing drops silently. The whole flow is documented in Import Historical Contracts.

Emails forwarded into a contract arrive with everything the chain picked up along the way: the documents that matter, plus signature logos, letterhead and tracking pixels. Until now, attachment extraction was all or nothing, set once for the whole company, and it skipped images entirely. Now every email event on the timeline carries a paperclip showing how many files came with it. Open it, tick the ones you want, and choose Copy to contract attachments.

The list puts documents above images and the largest file first, and on a long email it folds the inline images behind a Show images link. Nothing is filtered away or deleted, so the odd image that turns out to matter is one click away. Automatic extraction still works as before for companies that have it on; the picker covers everything it skips. The paperclip appears on emails captured from this release onward. The email-in guide covers both the picker and automatic extraction.

Also in this update:

Email conversations grouped: Consecutive emails in the same thread now appear as one expandable conversation on the timeline, so a long back-and-forth reads as a single item with a count instead of a dozen separate cards. Nothing is hidden. Expand the group to see every message.

Shorter email-in addresses: New contract email-in addresses drop the type token, so an address now reads acme-2026-0005 rather than acme-t-2026-0005 before the @. Existing addresses in signatures, address books and CC threads keep working.

Sometimes a contract needs a particular reference: the number a counterparty already quotes, a slot left by a record created outside Pactly, or a correction after a wrong entry. Those requests used to go to support. Administrators can now choose Assign Reference Number from the contract’s action menu, enter the number, and save. Pactly checks that the reference is not already in use within your company before applying it, and writes the change to the contract timeline and audit trail.

Reference generation now guards against collisions as well. If an assigned number sits ahead of the running counter, new contracts skip over it rather than ever producing a duplicate reference. Reference formats and year reassignment are covered in Configuring Contract Reference Numbers.

Ctrl+K (Cmd+K on Mac) reached contracts, parties, forms and templates. It now reaches settings too. Type the name of a setting, a section heading or a tab, such as “SSO”, “renewal rules” or “custom logo”, and the matching settings pages, boxes and tabs appear at the top of the results before the record matches load. Selecting one takes you to the page and scrolls to that section, opening the right tab first when the setting lives on one.

Settings results appear for administrators, since settings are an admin surface. Master-admin-only areas and features your company has not enabled stay out of the list. More on the palette is in the quick search guide.

Under time pressure, it is easy to clear a contract off the queue while a step is still outstanding. Now, when you click Finalize on a contract that still has pending work, Pactly first shows a warning naming what is open: form requests awaiting completion, pending approvals, or an active signature request. The same reminder appears when you send an approval request while a form request is still open.

The warning is deliberately not a block. Choose Dismiss to follow up the pending items first, or Finalize Anyway to proceed on purpose. Finalizing does not complete or cancel the outstanding work, so the decision stays with you rather than with a rule. The finalize guide describes the warning and what counts as pending work.

Your own systems can now generate Pactly contracts. Post a set of values to POST /v1/contracts/generate with a template ID, and Pactly fills the template, creates the contract and returns it, ready to download as a Word document. Every template’s detail page now has an API integration section listing its ID and the variables, value lists and parties it takes, with a one-click copy of the ID, so an integrator never has to ask what a template expects.

Options per request: Each call decides whether the contract is kept. Persisted contracts land in Pactly like any other, with workflows firing by default unless you turn them off. Ephemeral ones (persist: false) return the generated document in the response and leave nothing behind, which suits previews and what-if generation. Validation is strict and specific: an unknown key, a wrong type, an unknown option or a missing required value returns a 400 that says exactly what is wrong.

Contracts generated this way carry an API chip on their timeline, and the API key that created them is named in the audit trail. Full request and response details are on the API reference.

Large AI edits in the Word add-in used to come at a cost. When an edit was too big for Word’s own editing API, the add-in rebuilt the paragraph as plain text, so headings lost their bold, lists lost their numbering, and character formatting disappeared even on the words the edit never touched.

Those edits now keep the paragraph’s formatting intact. Kept text stays exactly as it was, deleted text is tracked as a deletion, and inserted text takes on the formatting of the text around it. Measured against Word’s own redlines, the result is on par with the small edits that always applied cleanly. Nothing changes in how you work: ask for the edit, review the tracked changes, accept or reject as before. Working with AI in Word is covered in the AI chat guide.

When the AI gets a cell wrong, or your judgement differs from it, you can now fix the value in the grid instead of re-writing the column prompt or exporting to Excel. Double-click a cell, or open its popover and click the pencil, and you get an editor matched to the column type: free text, a number, a date, a yes/no toggle, or the defined options for a list column.

Corrected cells stay legible at a glance. A blue pencil marks a cell you edited, a green tick marks one you confirmed without changing (saving a value as-is records it as verified, which is what a compliance sign-off actually needs). The popover shows who changed it and when, keeps the AI’s original value and its reasoning underneath, and offers Revert to AI value if you change your mind.

Your corrections hold. Re-running a column skips cells that have been edited, so a fresh analysis never quietly overwrites your work, and computed status columns and exports consume the corrected value rather than the superseded one. If the column definition changes after you reviewed a cell, the cell tells you so and asks you to review it again.

You can now protect a signing link with an access code. Open a recipient’s settings in the signing panel, switch on the lock, and set a code. When that recipient clicks their link, Pactly asks for the code before showing anything: no document, no fields, no contract details until they get it right.

You give the code to the signer yourself, by phone or chat or a separate message, which is what makes it a second factor: knowing the email is no longer enough. Codes are set per recipient, so one signer on an envelope can be gated while another is not, and you only turn it on for the sends that warrant it.

After three wrong attempts the recipient is locked out for a period and told when they can try again. Every submission, successful or not, is written to the envelope’s audit trail with a timestamp and appears on the audit certificate, so the evidence of who was challenged and when travels with the signed document. Codes are stored hashed, never in plain text, and are never shown back in the app.

A contract’s approval chain used to live only in the app, which was awkward when someone outside it needed proof the agreement had been signed off. You can now download that chain as a PDF from the approval card on the contract timeline: approver names, their decisions, timestamps, the order they came in, their comments, and any rows a reassignment or removal invalidated, with the reasons given.

Attach it to a signing request. When you send through Pactly E-Signatures, tick Attach approval trail and Pactly generates the same document and attaches it to the recipient emails, so there is no download-and-re-upload loop. The option only appears once the contract’s latest approval cycle is approved, and it is off by default on every send: it is a deliberate choice each time, never a company-wide setting.

The copy that goes to signers is trimmed for external eyes. It carries the approver names, decisions, dates, and sequence, and leaves out approver comments, removal reasons, and email addresses. Combined with per-recipient attachment visibility, you can also decide exactly which recipients receive it.

Some form questions ask for wording that most people cannot draft from scratch: standard terms to note, a confidentiality header, the clause your legal team always wants on a particular kind of agreement. There is now a company snippet library for exactly this. Go to Settings → Snippets, save each approved wording with a name, a short description, and any tags you want to group it by.

On any rich text form field, switch on Offer saved snippets on this field. Leave the tags empty to offer the whole library, or pick tags to narrow it to the ones that belong on that question. The person filling the form sees a Use snippet button beside the question, picks from the list, and the wording drops into the editor fully editable, so they can adjust it to their situation rather than starting from a blank box.

The library has search and a tag filter, so it stays usable as it grows, and it works on public forms as well as internal ones. Changing an approved wording is a snippet edit, not a form rebuild.

Date and number columns used to show whatever the extraction produced, and the only way to influence that was to describe the format you wanted inside the question itself, which was neither obvious nor reliable. Date and number columns now have a format picker in the column editor.

Dates can display as 15 Jan 2024, 15 January 2024, Jan 15, 2024, January 15, 2024, 15/01/2024, 01/15/2024, or ISO 2024-01-15. Numbers can be plain, use a thousands separator, show two decimal places, or render as a percentage. Choose Other if you would rather control the format from the question, and the extracted value is shown exactly as it came out.

Formatting is applied at display time, so changing it is instant and costs nothing: no re-extraction, no re-analysis of the column. Exports to CSV and Excel follow the same setting.

When a Project column should land on one of a few known answers, you can now define those answers instead of letting the AI free-text. Give the column its options (for example Assignable with consent, Assignable with notice, Not assignable), and Pactly classifies each contract into one of them, or returns blank when none apply. A column can allow a single option or several, and the results render as colour-coded pills so it reads at a glance.

When the options are really a checklist of requirements, a column can display as a coverage score: an X / N badge showing how many of the points were met, with the met and unmet items listed on hover. Feed that into an overall status column and the project rolls each contract up to a single verdict, colour-banded from non-compliant to compliant.

You can also compare a contract against more than one reference document in a single column: Pactly picks the closest match and names which reference it matched. And if you start a large analysis and change your mind, Stop Analysis halts the run while keeping every cell that already finished.

Reviewing a contract in a Project’s document preview, you can now search inside it. Press Ctrl-F (Cmd-F on Mac) or click the search icon, type a keyword, and Pactly highlights every match and moves you between them with the arrows or Enter. A counter shows where you are, and Escape clears it.

It works on both kinds of preview: contracts converted from Word, and PDFs rendered with their text layer, including scanned PDFs that have been run through OCR. Matches are punctuation-tolerant, so a search still lands even across smart quotes and different dash styles. If a scanned PDF has no readable text at all, the search tells you so rather than coming up empty.

Importing a legacy contract archive used to mean setting the name, category, and date for every file by hand. Now you drop the whole batch into the bulk importer, review everything in a staging table, and let AI handle the tedious parts when you hit import.

AI classification and smart renaming: As each file is imported, Pactly reads the document, categorizes it by contract type, and renames it using a configurable naming pattern (for example, type, counterparty, and year). Anything you set yourself in the staging table always wins over the AI, and classification runs at no extra credit cost.

Document preview: Click any staged file to preview it in a side panel without leaving the import screen, so you can check what a file actually is before importing. Works for both PDF and Word files.

Duplicate detection: If the same file is staged twice, the later copy is flagged as a duplicate with a one-click remove, plus a “Review duplicates” summary when a batch has several. Nothing is removed without your say-so.

The right reference year: Imported contracts used to take on the import date, so a 2019 contract got a current-year reference number. Now each file gets a reference year, extracted by AI from the document and editable per row or in bulk before importing. When no year can be detected, the contract is imported into the current year and flagged so you can find and fix it later. Admins also get a new “Reassign reference year” action on any contract to move a reference into the correct year cleanly, with the change recorded on the contract timeline.

Many teams don’t have a written review playbook, but they do have their standard template: the contract they always start from. You can now upload that template and have Pactly build a draft playbook from it, instead of only being able to import documents that were already written as playbooks.

Pactly detects automatically whether your upload is a playbook or a contract template, and you can correct it if the guess is wrong. For a template, it asks two quick questions first: which side of the contract you’re usually on (buyer, supplier, or either) and how firm your risk posture is. It then extracts each clause’s actual wording as your preferred position, saves that language to your clause bank, and suggests the parts a template can’t tell it: acceptable alternative fallbacks, which deviations should require approval, and a short rationale per position.

Everything the AI inferred is clearly badged as “AI-suggested” in the draft editor, separate from the language taken directly from your template, so you know exactly what to confirm before publishing. Like all imports, the result is a draft; nothing goes live until you review and publish it.

Renewal reminders are driven by your company-wide rules, which works for most contracts, but some deals need their own treatment. You can now edit the reminder schedule and recipients directly on a contract’s Renewal & expiry tab.

The first edit detaches that contract from the company defaults: it keeps your custom schedule and recipients even if the global rules change later. The tab shows a clear “Customized for this contract” state, and a “Reset to company default” button re-attaches it whenever you want the global rules to apply again. Recipients can be roles on the contract (requester, contract owner) or any email address. The renewal dates themselves always stay live, so if a date is corrected or re-extracted, your custom reminders re-anchor to the new date automatically.

Find contracts with unconfirmed end dates: The “Expiring soon” filter on the contracts list has a new “Needs review” option that surfaces contracts where no end date could be confirmed, for example when it depends on a linked agreement. These are exactly the contracts that silently escape date-based filters, and now you can list them all in one click.

The workflow editor used to show actions one event at a time, so once your automation grew past a handful of rules there was no way to see everything at once. It’s now a single table of all actions in the view, with search, an event filter, and sorting.

Each row shows the action’s summary: its type, name, conditions, and an active toggle. Click a row to expand the full configuration and rules editor in place. Actions shared across multiple events appear once, with a chip per event, so you can see at a glance where each automation applies. A free-text search finds actions by name or type, and the event filter narrows the table to a single trigger when you want the old per-event view.

Adding an action now starts by picking the event it should respond to, so you’re only offered action types that make sense for that trigger. Custom events can also be renamed inline by clicking their name.

Documents signed with Pactly E-Signatures now carry a digital seal from an Adobe-trusted certificate authority. When anyone opens a signed PDF in Adobe Acrobat or Reader, they see the green checkmark with a verified signer identity and confirmation that the document has not been modified since signing.

This is the same class of cryptographic seal used by the major e-signature providers, so signed documents you send to counterparties validate instantly, with no “signature validity unknown” warnings. The seal is tamper-evident: any change to the document after signing invalidates it visibly.

Only a cryptographic fingerprint of the document is used to produce the seal. The document itself never leaves Pactly’s infrastructure.

Pactly now integrates with Microsoft Entra ID for enterprise sign-in and user management, on both the web app and the Word add-in.

Single sign-on: Users from a connected organization sign in through your identity provider. The login page recognizes your domain from the email address and takes users straight to your organization’s sign-in, hiding the password and signup options that no longer apply. If someone from an SSO organization tries to sign up for a separate account, Pactly redirects them to sign in instead of letting a stray trial account be created.

Automatic user provisioning (SCIM): Connect Entra ID provisioning to create and deactivate Pactly users automatically as people join and leave your organization. Deactivation immediately ends the user’s sessions, and you control exactly which operations the sync is allowed to perform.

Scheduled enforcement: When you’re ready to require SSO, pick the verified domains it applies to and set a cutoff date. Before the cutoff, both password and SSO sign-in work, giving your users a grace period to switch. After it, the selected domains require a fresh SSO session, and older sessions are signed out.

Press Ctrl+K (or Cmd+K on Mac) from anywhere in Pactly to open a global search palette. Type a party name, a contract reference, or a term from one of your intake forms, and see matching contracts, parties, and templates grouped by type. Click a result to go straight to that record.

This replaces hunting through per-view filters and manual navigation, which gets slow once you have hundreds of contracts and parties. Search runs across entity types at once, so “Acme Corp” surfaces the party, its contracts, and related templates in one list. Results are tuned for the way people actually search: by entity name, by reference number, or by values that appeared on a form.

Search quality also got a pass this release: typo tolerance, smarter matching, and better recall mean you find the right record even when the query isn’t exact.

We’ve reworked renewal and expiry tracking to be far more operational. Reminders used to be manual and one-off, set per contract and easy to forget. Now every contract has a Renewal & expiry tab that automatically schedules reminders a set number of days, like 60 and 30, before the moment that actually matters: the deadline to give notice of renewal or non-renewal on an auto-renewing contract. The whole sequence is laid out on a visual timeline, and renewal dates are read from standard contract properties and extracted automatically, so the tab fills itself in as documents are processed.

Driven by your rules: Admins set notification rules that control who gets reminded, and how many days ahead, before a renewal or expiry. Rules can be scoped, for example NDAs in a specific business group above a certain value notify two people at 90/60/30 days, while everything else notifies the contract owner at 60/30. A baseline default rule applies out of the box, so reminders work before you configure anything.

Expiring soon view: The main contracts list can now filter and sort by what’s expiring next. Pick a window (next 30, 60, or 90 days) and an “Expiring in” column surfaces so you can see and act on the most urgent contracts first.

The visual reports area has been rebuilt around a shared frame: consistent chrome across every report, date-range scoping, and the ability to drill from a chart straight into the underlying contract list through a side drawer.

Reworked reports: The Workload report gets a richer in-flight view with stalled buckets and pipeline-over-time. Turnaround now shows medians, a by-type breakdown, negotiation rounds, and an honest funnel. Volume adds configurable leaderboards, owner share-of-total, and breakdowns by custom property with hierarchy drill-down and an inline dimension picker.

Configurable periods: You choose the reporting period and the comparison period, so trends and deltas reflect the window you care about rather than a fixed default.

Per-card visibility: Each visual report can be shared with specific users or roles, defaulting to admin-only, matching the per-report controls already available for data exports. Reports a viewer isn’t entitled to see are hidden, including by direct URL.

Most legal teams already have their review playbooks and position guidance written up in Word. You can now upload that .docx and have Pactly convert it into a playbook draft, instead of rebuilding the whole thing by hand one position at a time.

Choose Import from a document in the Add Playbook dialog, drop in your file, and Pactly parses each section or clause into a Pactly position, mapping the source content to description, fallback language, notes, keywords, and an approval-required flag. The result is a draft you review and edit before publishing, so you stay in control of what goes live. It’s been validated against a range of real customer formats, from NDA/MOU guidance docs to clause banks and review matrices.

When you place fields in the e-signature placement editor, you can now pre-fill values that the signer sees when they open the document. Use it for anything you already know, like a company name, a contract reference, or a checkbox that should default to checked, to save the signer time and avoid errors.

Pre-fill works for text, checkbox, and date fields. By default signers can edit the values you set, but you can flip a lock toggle per field to make a pre-filled value read-only when it shouldn’t be changed. Signature and initial fields always require the signer’s own input, so they’re excluded.

Once an approval request is in flight, you can now handle the three things that interrupt it, all from the contract’s approval area, with a consistent audit trail and notifications.

Cancel the whole request when you sent it to the wrong approver or the content has gone stale. Edit the approver chain to replace someone unavailable or add another approver. And when an approver rejects, the right people are reliably told the approval has stopped, following your routing rules. Each of these shares the same recovery path, so a stalled approval is easy to re-trigger rather than start over.

As teams track more and more data on each contract, the property list grows into dozens of fields spread across many groups, and finding a specific one means remembering which group it lives in and clicking through them one by one. The contract Properties tab now has a search box at the top of the sidebar. Type two or more characters and it filters properties across every group at once, matching on property labels, subgroup names, and values.

Matching properties appear grouped under their headings with a total match count, and each sidebar group shows how many matches it contains. Groups with no matches are dimmed. Clearing the search restores the normal single-group view. On contracts with a hundred or more properties, this turns a hunt into a single lookup.

Two changes to make outstanding approvals easier to track and resolve.

Pending Approvals view: Approvers now get a dedicated default view in the contracts list showing every contract waiting on their decision. Sequential approvals only appear once it’s actually your turn, and the view stays hidden when you have nothing to act on, so it doesn’t clutter the list. Sorted oldest first so the most overdue items rise to the top.

Manual Send Approval Request button: When a workflow doesn’t auto-fire (misconfigured trigger, condition not met, or a previous approval was rejected and needs to be redone), you can now send the request manually from the contract’s approval area. The button uses your configured approvers and fires the same notifications as an automated request.

When you archive, abort, delete, or schedule a contract for abort, any outstanding approval requests and signature requests are now handled consistently instead of being left in limbo.

If a contract has pending work at the moment you take one of these actions, Pactly now asks what you want to do: complete the pending items first, or cancel them and proceed. If nothing is pending, the action runs without a prompt. Either way, the side effects are logged on the contract timeline so the audit trail is clear.

This cleans up a long-standing source of noise: approval reminders and pending-work surfaces should no longer mention contracts that have already been archived or aborted.

Another round of polish on Pactly E-Signatures.

Internal users as recipients: The recipient picker now lists account users alongside contacts, so you can send a document to an approver or colleague without having to add them to the contact book first. A contact record is created behind the scenes when you select them, so they can still be used as a party on the contract.

Viewed events on the activity timeline: When a signer opens the signing page for the first time, a “viewed” event is recorded on the contract timeline alongside the existing sent and signed events. Useful for follow-up decisions and a more complete audit trail.

Refreshed signer emails: The signing request, reminder, and expiration warning emails got a layout and copy pass to look less like system notifications and more like a polished part of the signing experience.

Admins can now control who sees which report in the Reports Catalog. Each report supports a per-report allowlist of users, roles, or both. When no allowlist is configured, the report stays visible to everyone with reports access (today’s behaviour).

This is useful when you want to give a specific team access to a narrow set of reports without exposing the rest of the catalog. The visibility filter is applied both when listing reports and when running them, so a crafted request cannot run a report a user is not entitled to see. Visibility changes are captured in the audit trail.

Reports and data exports now live together under a single Reports section. Visual dashboards (productivity, turnaround, volume) sit alongside downloadable CSV and XLSX exports in one catalog, each with its own description and filters.

New Reports role: Users with the Reports role land on the Reports page after login and see only what you’ve made available to them. Useful for finance, compliance, or operations teams who need to pull data without touching contract records.

Data collection points across the contract lifecycle often look mostly the same but in some cases, may vary a little from transaction to transaction. You can now use customizable forms to start from a base form and tweak it each time you send it to capture that transaction-specific context. This avoids having to maintain separate forms for every variation.

A “Customize Form” step appears in the send flow. You can preview the form, hide questions that don’t apply, rewrite labels, or add a few extra fields right before you hit send. Each customized version is named so you can tell them apart later.

You can now enable automatic reminder emails for pending form submissions. Configure the initial delay, the interval between reminders, and a maximum count per form, and Pactly handles the follow-up so you don’t have to chase submissions by hand.

Reminder history is tracked on each form entry and surfaced on the form entries list as a quick status like “2 reminders sent, last 3 days ago”. Reminders stop automatically when the form is submitted, cancelled, or reaches the max count. Manual “Send Reminder” still works as before and is logged in the same history.

Completed form submissions can now be downloaded as a clean PDF directly from the form entries list. Text is selectable and copy-pasteable, so you can extract content for records, filings, or circulation outside Pactly. The PDF includes the form title, submission date, submitter details, and every question with its answer, with file attachments shown as links and signatures embedded as images.

Per-send notification recipients: The send flow now includes a notification recipients field, so you can pick who gets emailed when that specific form is submitted. These recipients supplement any defaults already configured on the form action, useful when the contract owner varies from send to send.

Another round of improvements to Pactly E-Signatures, focused on cleaner documents and fewer dead ends for signers.

Configurable audit trail: The signed PDF now comes in two versions, one with the audit trail appended and one without, both accessible from the contract record. A new company-level setting controls which version is treated as the primary executed document.

Word comments and tracked changes stripped automatically: When a document is sent for signing, Word comments are removed and tracked changes are flattened to the final visible state, so signers never see internal negotiation notes or markup in the signed PDF. If your document contains comments or unresolved track changes at send-time, a warning banner now tells you they’ll be removed before signing.

Expiration warning emails: Pending signers now receive a warning email a few days before their signing link expires, with a refreshed link and a clear call to action. No more dead “signing request expired” pages and no more cancel-and-recreate loops.

When the wrong file ends up in the executed slot, for example a half-signed PDF or a misfiled upload, admins and managers can now remove it directly from the Versions panel. Previously this required a support request to clear the record in the database.

A bin icon appears next to the executed document row. On click, a destructive confirmation dialog asks you to confirm before deleting the file and logging the removal to the timeline. For DocuSign, AdobeSign, and SignWell contracts, the dialog reminds you that the original signed envelope still exists with the provider.

Form field conditions now support date comparisons. You can gate the visibility of a question, or decide which template to generate, based on whether a date field is before, after, on, or equal to a fixed date.

The new operators (is before, is after, is on or before, is on or after, is) work the same way as the numeric comparison operators. Pick a date field, choose an operator, and set the comparison date with a date picker. This unlocks intake gating patterns like “if the agreement start date is before 15 April 2025, suppress this template and route the request to a reviewer”.

A round of improvements across the Pactly E-Signatures sender and signer experience.

Guided signing flow: Signers are now walked through fields one at a time. The document auto-scrolls to each field, a progress indicator shows how many fields remain, and completing one field automatically advances to the next. No more hunting through a multi-page document to find where to sign.

Resizable fields: Signature boxes, text fields, and other field types can now be resized with drag handles after placement. Previously, all fields were fixed at their default size with no way to adjust.

Custom text field labels: When placing text fields, senders can now set labels like “Name”, “Title”, or “Company”. The label appears as placeholder text on the document and in the guided signing step list, so signers know exactly what to enter in each field.

Field placement polish: The sidebar has been reorganized with signer selection above field types, clearer section headers, and an info banner explaining the workflow. Inactive signers are visually muted while the active signer is prominent. Field properties now show a toggle switch for required fields and inline delete.

Page boundary clamping: Fields can no longer be dragged or resized beyond the page edges, preventing truncated signatures and text in the final signed PDF.

Form data in signing emails: When a contract has an attached form, the form data and any additional files now appear in the signature request email and signing timeline, giving signers full context alongside the document.

Settings page improvements: The e-sign settings modal is wider and easier to scan, with a visual timeline preview showing exactly when reminders will be sent based on your configured schedule.

The party filter on the contracts list now supports fuzzy matching, so you no longer need to type the exact full name. Searching “acme” will find “Acme Holdings Pte Ltd”, and a partial name or slight misspelling still returns the right results.

Selecting multiple parties now narrows your results to contracts where all of those parties are involved, making it straightforward to find, for example, every agreement between two specific companies.

Attachment previews now show the full PDF document instead of just the first three pages. Pages load progressively as you scroll, so the preview opens instantly and remaining pages render in the background.

Previously, attachment previews cut off after three pages with a static “X more pages…” label and no way to see the rest without downloading the file.

Search and selection dialogs across the app now open instantly, regardless of how many options they contain. This applies anywhere you pick from a long list: adding signers, selecting approvers, choosing parties, and other selection flows.

Dialogs load an initial batch of results immediately and render more as you scroll. On accounts with large contact books, this eliminates the noticeable delay that used to occur when opening these pickers.

Admins can configure rules per contract type that require specific properties to be filled or parties to be verified before finalization is allowed. Rules are fully configurable: an project agreement might require project title and expiration date, while an MOU might require a purpose.

When a rule isn’t met, the finalize action is disabled and the blocking reasons are shown inline, so contract owners know exactly what needs to be resolved. Admins can override when needed, with every override logged in the contract timeline.

Contracts often involve many steps: verifying that key fields are filled for data hygiene, confirming the right people are assigned, or making sure certain conditions are met before the next stage. We are introducing a new checklist in the contract sidebar that brings all of this into one place instead of relying on memory or tribal knowledge.

Checklist items come in two types. Automated items reflect the current state of the contract, like whether required properties are filled or dates are set. These update in real time as you work. Manual items are for things the system cannot verify on its own, like confirming a document has been reviewed or that internal sign-off has been obtained. Officers tick these off explicitly.

The checklist is fully configurable per organization and per contract type, so different agreements show only the checks relevant to them.

Admins and managers can now mark contracts for abort, either individually or in bulk from the contracts list. Marked contracts enter a 30-day pipeline: the requester receives an email notification, and after 30 days the contract is automatically aborted unless cancelled.

When a contract is marked, a timeline item records the scheduled abort date. Admins can cancel the abort at any time from the timeline, which removes the contract from the pipeline and logs the cancellation.

For bulk operations, requesters with multiple affected contracts receive a single digest email listing all their contracts rather than one email per contract. Automated rules can also be configured to mark contracts matching specific criteria (e.g., unassigned drafts older than 12 months) on a recurring schedule.

You can now run due diligence, audits, or benchmarking exercises across your contract portfolio directly in Projects. Select the contracts you want to compare, then define your extraction columns: what specific positions or provisions you want to review across all of them. This could be termination for convenience rights, change of control clauses, notification obligations, governing law, or any other clause position relevant to your review.

Once your extraction columns are set up, Pactly populates a spreadsheet-style grid with the extracted clause text for each contract. Click any cell to preview the relevant source text in a side panel for quick verification.

We see this being used for post-merger contract audits, benchmarking clause positions across a vendor portfolio, and compliance reviews where teams need to verify specific provisions exist across a set of agreements. Projects is now available for early testing. Let us know how you’d like to use it.

The navigation sidebar can now be collapsed to an icon-only view, giving you more horizontal space for data-dense pages like Projects and contract lists.

Press [ to toggle between full and compact modes, or click the collapse toggle. Your preference is remembered across sessions. The sidebar also auto-collapses on narrower screens and restores when you resize back.

Admins and managers can now delete document rounds directly from the Document tab. Previously, removing duplicate or incorrect versions required a support request.

Each round shows a delete button with a confirmation step. Deletions are logged in the contract timeline with the round name and who removed it, maintaining a full audit trail.

A new bulk action on the contracts list lets you extract parties from multiple contracts at once. You can choose between two modes: extract as suggestions (requiring manual confirmation before parties appear in your contact book) or extract and auto-confirm in one step.

Progress is tracked in real time with a count of contracts processed and parties found.

A new “Bulk Reference” filter on the contracts list lets you paste multiple contract reference numbers at once. Open the filters panel, select “Bulk Reference”, and paste your references separated by commas, line breaks, or tabs. The list instantly filters to show only the matching contracts. Useful when working from exported data or reconciling a list of references.

Several improvements across our signing providers:

1. Custom email subjects (all providers): The email subject line for signature requests is now configurable per contract, so recipients can identify which contract they’re being asked to sign before opening the email.

2. Additional recipient roles (Pactly E-Signatures): Signing workflows now support Viewer and mid-flow CC roles. Legal counsel or other stakeholders can review documents during the signing process, not just after completion.

3. Non-signer field warnings (SignWell): When all signers have completed their signatures but non-signer fields (like date fields assigned to reviewers) are still pending, Pactly now shows a warning explaining why the contract hasn’t transitioned to “signed” status.

Status filtering: The form entries list now supports filtering by status, making it easier to find entries that need action.

Auto-archive stale drafts: Draft form entries older than a configurable threshold (e.g., 90 days) are now automatically archived, keeping your entries list focused on active work.

Deleted contract indicators: When a contract linked to a form entry has been deleted, the entry now shows this clearly with the name of who deleted it, instead of displaying a broken link.

OAuth2 authentication: The Pactly MCP server now supports OAuth2-based authentication, so you can connect from AI tools without managing API tokens manually.