docugenerate.com

DocuGenerate counts documents generated, not pages. A 100-page report counts as one document, the same as a one-page letter. Every plan, including the Free one, includes the same standard features: generated document links that never expire, overage handling instead of forced upgrades, and access to the PDF Generation API. If your workload is page-heavy but document-light, this counting model works in your favor.

How Document Counting Works

The unit of billing is the generated document, not the page. When you feed a template and a data set into DocuGenerate, each data item produces one document — regardless of how long that document turns out to be.

This matters if you generate long documents: reports, agreements, or certificates with many pages. Under a page-based model those would consume far more of your quota. Here, length is free.

The practical takeaway: estimate your monthly volume by counting data rows, not page count. If you generate one invoice per customer per month, your document count equals your customer count.

What Every Plan Includes

DocuGenerate states that features other tools reserve for higher tiers are standard on all plans, including the Free one. The confirmed standard features are:

• Documents, not pages — page count does not affect your quota.
• Links never expire — generated documents stay available until you delete them, rather than being purged after a retention window.
• Overage, not upgrades — if you go past your monthly volume, you are handled as overage rather than being forced onto a higher plan.
• PDF Generation API — the REST API is available on all plans, with a Quick Start Guide for developers.

The API point is worth noting: some document-generation services gate API access behind paid tiers. Here it is listed as a standard feature across plans.

What You Can Generate

The platform produces PDF documents from Word templates plus JSON or Excel data. Document types named on the site include invoices, letters, contracts, agreements, certificates, and proposals.

The workflow is:

1. Prepare a Word template with merge tags where dynamic text should appear.
2. Provide the data as JSON or an Excel file.
3. Generate — for each data item, the merge tags are replaced with actual values and a document is produced.

Templates can be uploaded in DOCX, DOC, ODT, TXT, or SQL format; data in JSON, XLSX, XLS, ODS, or CSV. Merge tags are auto-detected after upload, and delimiters can be changed from the default [Name] style to something custom like «Name» or {Name}. Templates support more than plain text: images, tables, lists, conditions, and QR codes can all be driven by merge tags.

You can generate through the web app, no-code integrations (Zapier, Make, n8n, Pipedream, and others), or the API.

Choosing Based on Your Volume

The counting model favors you when documents are long and few. It works against you only if you generate many short documents — in that case, your quota is consumed by row count, not by output size.

Two conditions to check before committing:

• Is your volume row-based or page-based? If you produce a small number of very long documents, the document-based count is a clear advantage.
• Do you need API access or permanent links? Both are standard here, so you do not need to compare tiers for them.

Pricing figures and the specific monthly document limits per plan are not covered in the available material — check the pricing page for current numbers before deciding.

OpenAPI-generated API documentation is reference documentation that is produced automatically from an OpenAPI description file rather than written by hand. You write (or generate) a machine-readable specification of your API — endpoints, parameters, request bodies, responses, schemas, and auth — and a documentation tool reads that file and renders a browsable, often interactive reference site. The spec becomes the single source of truth; the docs become a build artifact.

This differs from manually written docs in one fundamental way: with hand-written docs, the prose is the source of truth and the API is described separately. With spec-driven docs, the API description is the source, and every page, table, and code sample is derived from it.

How the workflow actually runs

A typical spec-driven documentation pipeline has five stages:

1. Author or generate the spec. You either write an OpenAPI document by hand (YAML or JSON), or generate it from code annotations, framework metadata, or a design-first editor. Design-first means the spec is written before implementation; code-first means it is extracted from existing code.
2. Validate and lint. The spec is checked against the OpenAPI schema and against style rules — consistent naming, required descriptions, no undocumented 4xx responses, no orphaned schemas.
3. Bundle and transform. Multi-file specs are combined, $ref pointers are resolved, and the document is optionally split into per-tag or per-version outputs.
4. Render. A documentation tool converts the spec into HTML: an endpoint list, a sidebar of operations, parameter tables, response schemas, and a "try it" console.
5. Publish and version. The rendered site is deployed, and each API version gets its own snapshot so consumers can read docs matching the version they call.

Steps 2 through 5 are usually automated in CI. If the spec fails validation, the docs build fails — which is the point.

Spec-driven vs. hand-written documentation

The practical conclusion most teams reach: generate the reference, write the guides. Reference material is repetitive and mechanical, which is exactly what generation is good at. Conceptual explanations, migration notes, and tutorials carry judgment that a spec cannot express.

What you get out of the box

Generated reference pages commonly include:

• An operation list grouped by tag or path, with HTTP method and path.
• Parameter tables showing name, location (path, query, header, cookie), type, required flag, and description.
• Request and response schemas rendered as expandable trees, including nested objects and arrays.
• Authentication details pulled from the securitySchemes section.
• Interactive request consoles that let a reader send a real call from the browser.
• Generated code samples in several languages, derived from the same schemas.
• Multiple output formats, such as a static site, a single HTML file, or a mock server.

Because all of these come from one document, changing a field name in the spec updates the parameter table, the schema tree, and every code sample at once.

Where spec-driven documentation breaks down

Generation is not free. The trade-offs are real:

Spec quality becomes documentation quality. A field with no description produces a table row with an empty cell. A vague summary produces a vague heading. Tools can enforce presence of descriptions via linting, but they cannot enforce that the description is useful.

Customization has limits. If you need a page that does not map to an OpenAPI concept — a conceptual overview, a pricing explanation, a comparison of two endpoints — you write it outside the generator and link to it.

Not everything is expressible. Webhooks, streaming responses, long-polling behavior, and complex multi-step flows are awkward or impossible to describe fully in OpenAPI. Those need prose.

The spec can go stale. If the spec is maintained separately from the implementation, it drifts just like hand-written docs. The mitigation is to generate the spec from code, or to test the implementation against the spec in CI.

Interactive consoles need care. A "try it" button that hits a production API with real credentials is a security and rate-limit problem. Point it at a sandbox, or disable it.

Deciding whether to adopt it

Adopt spec-driven reference documentation if most of these are true:

• Your API has more than a handful of endpoints, or changes frequently.
• You ship client SDKs or code samples in more than one language.
• Multiple teams consume the API and need a consistent, always-current reference.
• You already have, or are willing to maintain, an OpenAPI description.

Stay with hand-written docs, or a hybrid, if:

• Your API is small and stable, and the reference fits on one page.
• Your documentation is mostly conceptual and contains little endpoint-level detail.
• You cannot commit to keeping the spec in sync with the implementation.

A reasonable middle path: generate the reference from the spec, and hand-write the getting-started guide, authentication walkthrough, and error-handling page. Link the two directions so readers can move from concept to endpoint and back.

A minimal starting checklist

1. Produce one valid OpenAPI document for a single API version.
2. Add a linter with rules for descriptions, operation IDs, and error responses.
3. Wire the docs build into CI so a failing spec fails the build.
4. Render the reference and review it as a reader, not as the author.
5. Write the two or three conceptual pages the generator cannot produce.
6. Version the published docs alongside the API version.

The core idea is simple: describe the API once, in a format both machines and humans can read, and let the reference documentation fall out of that description. Everything else — tooling, hosting, interactivity — is a detail on top of that decision.

A PDF invoice in legal billing is a fixed-format document that presents the fees and costs owed on a matter in a layout that looks the same on every device. It is the digital equivalent of a printed bill: readable, portable, and easy to attach to an email or upload to a client portal. Its main limitation is that it is not machine-readable in the way a LEDES file is, so a client's e-billing system cannot automatically ingest it. PDF works best for flat-fee matters, small or one-off engagements, and clients who do not run an automated billing platform.

What "PDF" means in a legal billing context

When a billing tool offers to send an invoice "in PDF," it is generating a rendered document rather than a structured data file. The distinction matters:

• PDF is a presentation format. A human reads it. Line items, totals, and matter details appear as text and tables on a page.
• LEDES (Legal Electronic Data Exchange Standard) is a structured, delimited text format. An e-billing system parses it, validates it against outside counsel guidelines, and routes it for review.
• Email delivery is a transport method, not a format. You can email a PDF, email a LEDES file, or email a link to an online invoice.

These three are often confused because a single invoice can combine them: a LEDES file delivered by email, or a PDF attached to an email. The format is what the client's systems can read; the delivery method is how it arrives.

When a PDF invoice is the right choice

PDF is usually appropriate when the client does not require electronic submission through a billing platform. Common scenarios:

• Flat-fee and fixed-price matters. When the invoice is one or two lines, a structured file adds no value.
• Small businesses and individuals. Clients without an accounts payable system can open a PDF and pay from it.
• Retainers and replenishment requests. A simple statement of the retainer balance is easy to read as a PDF.
• Pro bono or courtesy bills. Where no formal e-billing review applies.
• Backup documentation. Even when a LEDES file is submitted, a PDF is often attached for the reviewer's convenience.

If the client has outside counsel guidelines requiring LEDES submission, a PDF alone will typically be rejected or returned for manual entry. Check the client's billing requirements before choosing the format.

PDF versus LEDES versus emailed invoice: a quick comparison

Core elements of a compliant legal PDF invoice

A PDF invoice should stand on its own. If a client's AP department picks it up with no context, it should still answer who, what, when, and how much.

Firm and client identification

• Firm name, address, and contact details
• Tax or VAT identification number where applicable
• Client name and billing contact
• Invoice number and invoice date
• Client matter number or reference

Matter and timekeeper detail

• Matter name and description
• For each timekeeper: name, initials, and billing rate
• Time entries with date, narrative description, and time recorded in tenths of an hour
• Clear separation of fee earners if rates differ

Fees, expenses, and totals

• Fees subtotal
• Disbursements and expenses, itemized with dates
• Taxes applied
• Prior payments, credits, or trust retainer applied
• Total amount due and currency

Payment terms

• Due date and payment window
• Accepted payment methods
• Remittance details or a payment link
• Late-payment terms if the engagement letter specifies them

A useful test: hand the PDF to someone who has never seen the matter and ask them to confirm the amount due and the period covered. If they hesitate, the invoice is missing something.

Practical limitations to plan around

PDF invoices shift work to the recipient. Someone at the client has to read the document and key the data into their system, which introduces delay and transcription errors. PDFs also cannot be validated against billing guidelines automatically, so a reviewer may reject a line item that a LEDES rule would have caught before submission.

Two habits reduce the friction:

1. Send a consistent template. Clients learn where to find the total, the matter number, and the payment terms.
2. Keep a LEDES version in reserve. If a client later adopts an e-billing platform, you can convert rather than rebuild.

Choosing between PDF, LEDES, and email delivery

Work from the client's requirements backward:

• Does the client mandate LEDES submission? If yes, PDF is a supplement, not a substitute.
• Is the matter flat-fee or very small? PDF is usually sufficient.
• Does the client have no billing system? PDF delivered by email or portal is the simplest path.
• Is the invoice complex with many timekeepers and expenses? A structured format reduces disputes, even if the client accepts PDF.

When in doubt, ask the client's billing contact which format they prefer and whether a PDF attachment is acceptable alongside any required file. That one question prevents most rejected invoices.

Easy Legal Billing supports sending or scheduling invoices in LEDES, email, or PDF formats, which lets you match the format to each client's requirements rather than forcing one approach across every matter.

DocuGenerate accepts DOCX, DOC, ODT, TXT, or SQL files as templates, and JSON, XLSX, XLS, ODS, or CSV files as data. You upload a Word-style template containing merge tags, supply the matching data, and DocuGenerate produces one PDF document per data item by replacing each tag with its value. This applies across the web app, no-code integrations, and the REST API.

Template formats

Templates are ordinary files you own and can download at any time. You design them in the document editor you already use rather than a proprietary builder.

Data formats

Each row or data item in the file generates one document. A 100-page output still counts as a single document, because DocuGenerate counts documents rather than pages.

How tags and delimiters work

1. Prepare the template — insert tags where dynamic text should appear, for example [Name].
2. Upload the template — merge tags are detected automatically from the template content, so you don't declare them manually.
3. Adjust delimiters if needed — you can switch from [Name] to a custom style such as «Name» or {Name}.
4. Provide the data — upload an Excel/CSV/ODS file or send JSON.
5. Generate — each data item produces a PDF with tags replaced by actual values.

Tags aren't limited to plain text: images, tables, lists, conditions, and QR codes can all be driven by merge tags.

Practical notes

• Matching formats: your data file and template are independent — you can pair a DOCX template with CSV data, or an ODT template with JSON.
• Delimiter conflicts: if your template text legitimately contains square brackets, switch to a custom delimiter to avoid false tag detection.
• Choosing a data format: CSV and XLSX suit manual, spreadsheet-driven runs; JSON fits API and integration pipelines where data comes from another system.

For current plan limits and pricing, check the pricing page, since generation allowances are tied to your plan rather than to file format.

DocuGenerate is an automated document generation platform that turns Word templates plus structured data into finished PDF documents. You prepare a Word file with merge tags where dynamic content should appear, supply the data as JSON or an Excel file, and the platform produces one document per data item by replacing each tag with its actual value. It fits recurring, data-driven paperwork such as invoices, letters, contracts, agreements, proposals, and certificates — especially when you want to keep designing in Word rather than in a proprietary template editor. You can drive it through the web app, no-code integrations, or a REST API, and the site offers a free way to start generating.

How the generation flow works

The mechanism is template-plus-data merging, and it runs the same way regardless of which interface you use:

1. Prepare the template. Build an ordinary Word document and place tags where dynamic text belongs.
2. Provide the data. Supply records as JSON or in a spreadsheet file.
3. Generate. For each data item, the platform replaces the merge tags with the real values and outputs a document.

Because the template is a normal Word file you own and can download at any time, you are not locked into a separate design tool — you edit in the document editor you already know.

Supported input formats

Working with tags

• Autodetect: After you upload a template, merge tags are detected automatically from the template content, so you don't have to register them by hand.
• Custom delimiters: You can change the tag delimiters — for example, from [Name] to «Name» or {Name} — which matters when your document legitimately contains square brackets.
• Beyond plain text: Tags can drive images, tables, lists, conditions, and QR codes, not just single text values.

Ways to run it

DocuGenerate exposes three routes to the same generation engine, so you can pick based on who is doing the work:

• Web app — for manual or occasional generation.
• No-code integrations — connect through automation and app-building tools. The site lists Zapier, Make, n8n, Pipedream, Bubble, Coda, Power Apps, Xano, and Backendless.
• REST API — for developers embedding generation into their own applications, with a Quick Start guide and API reference available.

What is standard on every plan

Some platform behaviors are worth knowing because they differ from common SaaS norms, and the site states they apply to all plans, including the Free one:

• Documents, not pages. Billing counts generated documents, so a 100-page report counts as one document.
• Links never expire. Generated documents remain available until you delete them, rather than being purged after a retention window.
• Overage, not upgrades. Exceeding your monthly volume is handled as overage rather than forcing a plan change.

When DocuGenerate is a good fit

Choose it when your documents are repetitive in structure but vary in data, and when your team already works in Word. Typical cases named by the platform include invoices, letters, contracts, agreements, proposals, and certificates.

It is a weaker fit if you need a fully bespoke layout engine that Word cannot express, or if you want to design templates only inside a browser-based builder — here the template stays a Word file by design.

To evaluate it, start with one real template and a small data file, confirm the tags are detected correctly, and check that conditions and tables render as expected before scaling up.