Contract data extraction

Contracts in. Key terms out.

Upload a contract as a PDF, Word file or scan, forward it by e-mail or send it to the API. Parsevix returns the parties, dates, value, renewal and termination terms, jurisdiction and signatures as structured data, ready for a contract register.

  • Parties, dates, value and currency
  • Renewal, termination and liability clauses as text
  • Personal data masked automatically before the AI step

No credit card · 20 free pages every month

What you get back

Parties, dates, value and clauses, already defined.

The built-in Contract category returns 26 fields: the contract itself, the parties, the value, the main clauses, the signatures, and lists of key terms, deliverables and amendments. Use it as it is, or change it in your project.

Dates come back as ISO dates and the value as a plain number; clause fields come back as text from the contract's own wording. A field the contract doesn't contain, such as a liability cap, is left out, not guessed.

Contract

  • contract_titlestring
  • contract_typestring
  • contract_numberstring
  • effective_datedate
  • expiration_datedate

Parties

partiesarray

  • namestring
  • rolestring
  • addressstring

Value and payment

  • contract_valuenumber
  • currencystring
  • payment_termsstring

Clauses

  • scope_of_workstring
  • renewal_termsstring
  • termination_clausestring
  • confidentiality_clausestring
  • liability_capstring
  • indemnificationstring
  • dispute_resolutionstring
  • jurisdictionstring

Signatures

signaturesarray

  • signer_namestring
  • signer_rolestring
  • signer_datedate

Lists

  • termsarray
  • deliverablesarray
  • amendmentsarray

Your own fields

A name, a type and one sentence on what it is.

  • notice_period
  • price_index
  • non_compete
  • governing_language

Made for contract registers

From a stack of contracts to a register.

Contracts are long, worded differently by every counterparty and full of dates that matter later. This is what Parsevix gives you from them.

01

Dates you can act on

Effective date, expiration date and the renewal terms come back as fields of their own. Your contract register or calendar can work out the last day to give notice and remind the right person before an agreement renews on its own.

Parsevix extracts what a contract says; it doesn't review or assess it, and it isn't legal advice.

  • 02

    Clauses as fields

    Renewal, termination, confidentiality, liability cap, indemnification, dispute resolution and jurisdiction come back as text fields of their own, taken from the contract's wording.

  • 03

    Every party with its role

    Each party comes back with its name, its role in the contract, such as client or contractor, and its address, however many parties there are.

  • 04

    Who signs, and when

    The signatories come back with the names, roles and dates printed next to the signature lines. A handwritten signature itself is not turned into a name.

  • 05

    Key terms, deliverables, amendments

    Lists in a contract come back as lists: key terms as text, deliverables one by one, amendments with their date and description.

  • 06

    Contracts in any language

    The language is detected on every page. A contract in another language fills the same fields, with ISO dates and plain numbers.

  • 07

    Names and addresses masked

    Names of people and companies and their addresses are masked automatically before any text goes to the AI model and put back in your result. Detection catches most personal data, not necessarily every item.

How contracts get in

Upload them, forward them or send them from your system.

Dashboard

Upload signed contracts as PDFs, Word files or scans. Check each result next to its page, with every value marked where it was printed, and approve it.

E-mail address

Paid plans

Every project gets its own address. Forward signed contracts to it, and each attachment becomes a document.

API

Send contracts from your contract management or document system and get the JSON in the same response, or receive results by signed webhook or through Zapier.

Request

curl https://parsevix.com/api/v1/extract \
  -H "X-API-Key: $PARSEVIX_API_KEY" \
  -F file=@service-agreement.pdf \
  -F category="Contract"

The request stays open until the document is read and answers with the JSON.

  • POST /documentsUpload without waiting; the result arrives by webhook or callback.
  • POST /extract-autoNo category: every field Parsevix finds, named as in the document.
  • POST /classifyOnly the document's category, for 1 credit.
Full API reference

Response · trimmed

{
"status": "Completed",
"category": "Contract",
"pageCount": 3,
"language": "en",
"extracted": {
"contract_title": "Service agreement",
"effective_date": "2026-01-01",
"expiration_date": "2027-12-31",
"contract_value": 48000.00,
…
},
…
}

Security & compliance

  • PII maskedautomatically, before the AI step
  • Encryptedin transit and at rest
  • No AI trainingon your documents
  • API files deletedafter processing

Priced per page, not per feature.

Every plan reads, sorts and masks documents the same way. Picking the category is included, and a document that fails costs nothing.

See pricing
credit per page
1
free pages every month
20
a month for 500 pages
$39

Contract FAQ

Contracts,
answered.

What teams ask before they send their first contracts.

Still have a question?

Write to us. A person reads every message.

PDF, Word (DOCX), PNG, JPG and TIFF, up to 10 MB and 30 pages each. Scanned signed copies work too; every page is read as an image.

A file can have up to 30 pages. A longer contract has to be split into files, and each part comes back as a result of its own, so fields from different parts are not merged.

No. It extracts what the contract says into fields. It doesn't judge whether a clause is fair, valid or risky, and nothing it returns is legal advice.

It reads the names, roles and dates printed or typed next to the signature lines. A handwritten signature itself is not turned into a name, and whether a contract is validly signed is not checked.

One credit per page: a twelve-page contract uses twelve. Choosing the category is included, and if a document fails, its credits are given back.

Contracts uploaded in the dashboard or sent by e-mail stay in your project until you delete them. Files sent through the API are deleted after processing unless you turn on keeping them for the project. Your contracts are never used to train AI.