How to Build E-Signatures Into Apps You Make With Google Antigravity

You're building an app with Google Antigravity, and at some point a user needs to sign something. A contract, an NDA, a consent form, an order. The usual answer is to bolt on a heavyweight signing vendor, sit through a sales cycle, and accept per-seat pricing that doesn't fit a product still finding its shape. There's a cleaner path. Firma.dev is an e-signature API you call from the app you're already building, and the full implementation steps live in the Antigravity integration guide so you can hand them straight to whoever writes the code.

If you haven't used it yet, Antigravity is Google's agent-first development tool, built around AI agents that can read context and act on it rather than just autocomplete. This piece is for founders and evaluators deciding whether the signing approach fits. It stays out of the code and focuses on what you get, what it costs, and how the pieces fit together.

Building e-signatures into an Antigravity app

The outcome first: a product built with Antigravity can send legally binding documents for signature and collect them back, without standing up a signing platform of your own and without a contract negotiation to get there. Your app sends a document, the signer gets a link, they sign, and you get a completed file plus an audit trail that records who signed and when.

Because there is no signing vendor sitting between you and your users, the experience stays inside your product. Signers don't bounce out to a third-party brand. The signing screen can be embedded in your own UI, so the flow looks like part of the app rather than a detour through someone else's tool.

The main path: Firma.dev in the app you're building

The primary way to use Firma.dev is as an API your application calls. When your app needs a signature, it sends the document to Firma.dev, which handles delivery to the signer, the signing experience, and the finished record. You can drop an embedded signing editor directly into your interface, so users never leave your product to complete a signature.

Firma.dev also ships two MCP servers, a Docs MCP and a Data MCP. Connected inside Antigravity, they let the agent read the live documentation and work against the API as it builds, which means the integration gets written without you hand-wiring every REST call. It's the same product either way. The MCP route just changes how you get the integration written. The build steps for both are in the official Antigravity guide, which is where the technical detail lives, including how to migrate over if you were using the Gemini CLI.

The alternative: let the Antigravity agent send the contract itself

Antigravity is agent-driven, so beyond writing the integration, an agent connected to Firma.dev's MCP servers can also operate on your Firma data directly. It can send a signing request, manage templates, and act on a document when prompted in plain language, rather than waiting for a button in your UI to fire the call.

This is useful if you're building something where the natural interface is conversation or an automated workflow rather than a fixed screen. It's an option worth knowing about, not the default. Most products will want the app itself to control when documents go out, with the agent path layered on where it genuinely helps. Either way the underlying call to Firma.dev is the same.

Why this is cheaper than the alternative

Firma.dev is pay-as-you-go at EUR 0.029 per envelope, which is roughly 3 cents USD. You pay for the documents you actually send, with no upfront cost, no monthly minimum, and no annual contract to sign before you can start. An envelope is a single signing request, so a document going to one signer or several signers counts as one envelope.

Compare that to the enterprise signing model, where pricing is built around per-seat licenses and tiered annual plans. That structure assumes a fixed set of internal users sending documents, which is the wrong shape for a SaaS product where signing volume rises and falls with your own customers' activity. Paying per envelope means your signing cost tracks usage directly, and a quiet month costs you almost nothing. For a product still growing, that difference compounds.

Built for products with many customers

If your Antigravity app serves multiple customers, you'll want their documents and templates kept apart. Firma.dev handles this with Customer Workspaces, which are private, partitioned spaces inside your account. Each customer gets isolated templates and their own envelope usage, so one customer's contracts and signing activity never mix with another's.

This matters for two reasons. The first is clean separation, which keeps each customer's data where it belongs and makes per-customer reporting straightforward. The second is that it scales with you. As you add customers, you add workspaces, without rearchitecting how signing works in your app. The structure is built for the multi-customer case from the start rather than retrofitted later.

Compliance, briefly

Firma.dev is designed for the major electronic signature frameworks. In the United States that means the ESIGN Act and UETA. In Europe it means eIDAS, supporting Simple Electronic Signatures and Advanced Electronic Signatures, and it is built to help you comply with GDPR for the personal data involved in a signing flow.

Every completed signature comes with an audit trail recording the signing events, which is the record you'd point to if a signature were ever questioned. If your specific use case has regulatory requirements beyond the common frameworks, it's worth confirming the details against your own legal guidance before you build. The point here is that legally binding signing is the baseline, not an add-on you have to engineer yourself.

Get started

If you're building with Antigravity and you want signing inside your product, the path is short. Start with the Antigravity integration guide for the implementation, whether you wire up the API directly or build it through the MCP servers. The same approach works across the other AI building tools too, so the e-signing layer you add to a Lovable app or a project in Cursor looks much the same.

Get started with Firma.dev for free, no credit card required.