Anvil 1.0.0

There is a newer version of this package available.
See the version list below for details.
dotnet add package Anvil --version 1.0.0
                    
NuGet\Install-Package Anvil -Version 1.0.0
                    
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="Anvil" Version="1.0.0" />
                    
For projects that support PackageReference, copy this XML node into the project file to reference the package.
<PackageVersion Include="Anvil" Version="1.0.0" />
                    
Directory.Packages.props
<PackageReference Include="Anvil" />
                    
Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.
paket add Anvil --version 1.0.0
                    
#r "nuget: Anvil, 1.0.0"
                    
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
#:package Anvil@1.0.0
                    
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.
#addin nuget:?package=Anvil&version=1.0.0
                    
Install as a Cake Addin
#tool nuget:?package=Anvil&version=1.0.0
                    
Install as a Cake Tool

Horizontal Lockupblack Horizontal Lockup copywhite

dotnet-anvil

Nuget (with prereleases) GitHub

This is a library that provides an interface to access the Anvil API from applications written in .NET languages: C# etc.

Anvil provides easy APIs for all things paperwork.

  1. PDF filling API - fill out a PDF template with a web request and structured JSON data.
  2. PDF generation API - send markdown or HTML and Anvil will render it to a PDF.
  3. Etch e-sign with API - customizable, embeddable, e-signature platform with an API to control the signing process end-to-end.
  4. Anvil Workflows (w/ API) - Webforms + PDF + e-sign with a powerful no-code builder. Easily collect structured data, generate PDFs, and request signatures.

Learn more on our Anvil developer page. See the API guide and the GraphQL reference for full documentation.

Usage

Install the Anvil package from NuGet. It targets .NET Standard 2.0 (.NET Core 2.0+, .NET 5+ or .NET Framework 4.6.1+) and .NET 10.

dotnet add package Anvil

Create a client with your API key, from your organization's API settings, and call the methods. Everything is async.

using Anvil;
using Anvil.Payloads;

var anvil = new AnvilClient(new AnvilClientOptions { ApiKey = "API-KEY-FROM-SETTINGS" });

// Fill a PDF template with data: the PDF's bytes
var pdf = await anvil.FillPdfAsync("pdf-template-eid", new FillPdfPayload
{
    Data = new Dictionary<string, object>
    {
        ["name"] = "Sally Jones",
        ["date"] = "2026-01-30",
    },
});
await File.WriteAllBytesAsync("filled.pdf", pdf);

One AnvilClient per API key: it is thread-safe, and paces requests to the API's rate limit. Dispose it when your app is done with it.

Types

The payload types in Anvil.Payloads (FillPdfPayload, GeneratePdfPayload, CreateEtchPacketPayload, EtchSigner, ...) extend types generated from the API's own OpenAPI spec and GraphQL schema (Anvil.Types), so every option the API documents is a property with XML docs, and enum values are constants like EtchSigner.SignerTypeValues.Embedded. A value the API adds later is accepted, and any JSON members a type doesn't declare are kept in AdditionalData. Every method also takes its payload as an anonymous object, a dictionary, a JObject or a JSON string with the same shape, and the GraphQL methods return the generated response types (EtchPacket, Submission, ...).

API

Instance methods

new AnvilClient(options)
var anvil = new AnvilClient(new AnvilClientOptions
{
    ApiKey = "...",                             // or AccessToken = "..."
    BaseUrl = "https://app.useanvil.com",       // the default
});

// Or, with the defaults
var anvil = new AnvilClient("API-KEY");

See Options for everything it takes.

FillPdfAsync

Fills a PDF template with your JSON data and returns the PDF. See the PDF filling guide.

First, you will need to have uploaded a PDF to Anvil. You can find the PDF template's ID on your PDF template's page:

Find your PDF Template ID

var payload = new FillPdfPayload
{
    Title = "My PDF Title",
    TextColor = "#CC0000",
    Data = new Dictionary<string, object>
    {
        { "simpleTextField", "string data" },
        // Some fields take an object. In your PDF template's API info page, you
        // can see if your field has additional data.
        { "phone", new { num = "5551231234", region = "US" } },
    },
};

// The PDF's bytes
byte[] pdf = await anvil.FillPdfAsync("pdf-template-eid", payload);

// Or a stream, to read a large PDF without holding it in memory
using Stream stream = await anvil.FillPdfStreamAsync("pdf-template-eid", payload);

// Or straight to a file
await anvil.FillPdfToFileAsync("pdf-template-eid", payload, "/tmp/filled.pdf");

// A version of the template to fill. When left out, the latest published
// version is used, or the latest draft if the template has never been published.
await anvil.FillPdfAsync("pdf-template-eid", payload, AnvilClient.VERSION_LATEST); // the latest draft
await anvil.FillPdfAsync("pdf-template-eid", payload, 5);                          // version 5

FillPdfPayload has every option the API documents: FontSize, FontFamily, TextColor, UseInteractiveFields, OutputFormat ("url" for a link instead of the PDF; the response is then the JSON's bytes) and more.

GeneratePdfAsync

Dynamically generates a new PDF from your HTML and CSS or markdown and returns it. See the PDF generation guide.

// Markdown (the default type)
var payload = new GeneratePdfPayload
{
    Title = "My Document Title",
    Data = new List<MarkdownContent>
    {
        new() { Label = "Name", Content = "Sally Jones" },
        new() { Content = "Lorem **ipsum** dolor sit _amet_." },
        new()
        {
            Table = new MarkdownTable
            {
                FirstRowHeaders = true,
                Rows = new List<List<string?>?>
                {
                    new() { "Description", "Quantity", "Price" },
                    new() { "4x Large Widgets", "4", "$40.00" },
                },
            },
        },
    },
};

// HTML and CSS
var payload = new GeneratePdfPayload
{
    Title = "My Document Title",
    Type = GeneratePdfPayload.TypeValues.Html,
    Data = new HtmlContent
    {
        Html = "<h1>Hello</h1><p>From the Anvil .NET client</p>",
        Css = "h1 { color: #4c5bf1; }",
    },
    Page = new Anvil.Types.Rest.PageOptions { Width = "8.5in", Height = "11in", Margin = "60px" },
};

byte[] pdf = await anvil.GeneratePdfAsync(payload);
using Stream stream = await anvil.GeneratePdfStreamAsync(payload);
await anvil.GeneratePdfToFileAsync(payload, "/tmp/generated.pdf");
CreateEtchPacketAsync

Creates an Etch packet: the documents to sign, the signers, and how they sign. Unless it is a draft, the packet is sent to its first signer. See the e-signature guide.

using Anvil.Types.GraphQL;

var payload = new CreateEtchPacketPayload
{
    Name = "Etch packet name",
    // Defaults: sent right away (IsDraft = false), as a test packet (IsTest = true)
    IsDraft = false,
    IsTest = true,
    SignatureEmailSubject = "Your signature is required",
    SignatureEmailBody = "Please sign this!",
    // Files: PDF templates from your account, uploaded PDFs, or PDFs generated
    // from HTML or Markdown. The Id is what signers' fields refer to.
    Files = new List<EtchFile>
    {
        new EtchCastRef { Id = "contract", CastEid = "pdf-template-eid" },
        new DocumentUpload
        {
            Id = "upload",
            Title = "Please sign this too",
            File = AnvilClient.PrepareGraphQLFile("/path/to/file.pdf"),   // or a Base64Upload
            Fields = new List<object>
            {
                new SignatureField { Id = "sig", Type = "signature", PageNum = 0, Rect = new Rect { X = 400, Y = 100, Width = 150, Height = 30 } },
            },
        },
    },
    // Data to fill the templates with before signing, keyed by file id
    Data = new { payloads = new { contract = new { data = new { name = "Sally Jones" } } } },
    Signers = new List<object>
    {
        new EtchSigner
        {
            Id = "signer1",
            Name = "Sally Jones",
            Email = "sally@example.com",
            // "email" (the default), "embedded" or "in-person"
            SignerType = EtchSigner.SignerTypeValues.Email,
            Fields = new List<object>
            {
                new SignerField { FileId = "contract", FieldId = "signature1" },
                new SignerField { FileId = "upload", FieldId = "sig" },
            },
        },
    },
    // If you'd like all the PDFs merged into one when signing, and in the resulting zip
    // MergePdfs = true,
    WebhookUrl = "https://example.com/anvil-webhook",
};

EtchPacket packet = await anvil.CreateEtchPacketAsync(payload);
Console.WriteLine($"{packet.Eid} {packet.Status} {packet.DetailsUrl}");
var signerEid = packet.DocumentGroup.Signers[0].Eid;

EtchSigner has every signer option the API documents: RoutingOrder, RedirectUrl, EnableEmails, RequireIdCheck, SignatureExperience, TokenValidForMinutes, AccessCode and more. CreateEtchPacketPayload has every argument of the createEtchPacket mutation: SignaturePageOptions, ReplyToName, ReplyToEmail, CreateCastTemplatesFromUploads, DuplicateCasts, AllowUpdates, OrganizationEid and more.

The response has the fields in Operations.CreateEtchPacketDefaultResponseQuery. To select others, pass a responseQuery, with or without the braces; fields the EtchPacket type doesn't have are in AdditionalData. To send your own mutation document, pass mutation.

var packet = await anvil.CreateEtchPacketAsync(payload, responseQuery: "eid status documentGroup { eid signers { eid } }");
GetEtchPacketAsync

Gets an Etch packet: its status, documents and signers.

using Anvil.Types.GraphQL;

EtchPacket packet = await anvil.GetEtchPacketAsync("etch-packet-eid");
Console.WriteLine($"{packet.Status}, {packet.NumberRemainingSigners} signers remaining");

// With a response query
var packet = await anvil.GetEtchPacketAsync("etch-packet-eid", responseQuery: "{ eid status }");
GenerateEtchSignUrlAsync

Generates the URL an embedded signer signs at. The packet and its signers must have already been created. See embedded signers.

// The signer's eid comes from the packet's DocumentGroup.Signers; the client
// user id is the signer's id in your system
string url = await anvil.GenerateEtchSignUrlAsync(signerEid, clientUserId: "your-user-id-123");
DownloadDocumentsAsync

Downloads the documents of an Etch packet's document group as a zip. See downloading documents.

byte[] zip = await anvil.DownloadDocumentsAsync(packet.DocumentGroup.Eid);
using Stream stream = await anvil.DownloadDocumentsStreamAsync(packet.DocumentGroup.Eid);
await anvil.DownloadDocumentsToFileAsync(packet.DocumentGroup.Eid, "/tmp/documents.zip");
ForgeSubmitAsync

Submits data to a Workflow's webform (Forge), creating or updating a submission. See the forgeSubmit reference.

using Anvil.Types.GraphQL;

Submission submission = await anvil.ForgeSubmitAsync(new ForgeSubmitPayload
{
    ForgeEid = "forge-eid",
    Payload = new { name = "Sally Jones", email = "sally@example.com" },
    IsTest = true,
    // To update an existing submission
    // WeldDataEid = "...", SubmissionEid = "...",
});
Console.WriteLine($"{submission.Eid} {submission.Status} {submission.ContinueUrl} {submission.WeldData.Eid}");

Takes responseQuery and mutation like CreateEtchPacketAsync.

RemoveWeldDataAsync

Removes a Workflow submission's data (WeldData). Returns whether it was removed.

bool removed = await anvil.RemoveWeldDataAsync(submission.WeldData.Eid);
RequestGraphQLAsync

Sends any GraphQL query or mutation and returns the response's data. See the GraphQL reference for everything the API has.

using Newtonsoft.Json.Linq;

JObject data = await anvil.RequestGraphQLAsync(@"
    query CurrentUser {
      currentUser { eid name email }
    }");
Console.WriteLine(data["currentUser"]["email"]);

// With variables: an anonymous object, a dictionary, a JObject or a payload type
var data = await anvil.RequestGraphQLAsync(
    "query Cast($eid: String!) { cast(eid: $eid) { eid title } }",
    new { eid = "pdf-template-eid" });

// Deserialized to a type, e.g. one generated from the schema
var data = await anvil.RequestGraphQLAsync<Dictionary<string, Anvil.Types.GraphQL.Cast>>(query, variables);
var cast = data["cast"];

A mutation with an Upload argument, like createCast, takes a file from PrepareGraphQLFile in its variables.

The response's errors throw an AnvilClientException. GetCurrentUserAsync() is a shortcut for the currentUser query.

RequestRestAsync

Sends any REST request. The path is on the client's BaseUrl, e.g. /api/v1/generate-pdf; a full URL is accepted if it is on the base URL, and refused otherwise.

using System.Text;
using Newtonsoft.Json.Linq;

// JSON in, JSON out
JToken json = await anvil.RequestRestAsync(HttpMethod.Post, "/api/v1/fill/pdf-template-eid.pdf", new
{
    data = new { name = "Sally" },
    outputFormat = "url",
});

// Deserialized to a type
var result = await anvil.RequestRestAsync<MyType>(HttpMethod.Get, "/api/v1/...");

// A binary response, as bytes or a stream
byte[] pdf = await anvil.RequestRestBytesAsync(HttpMethod.Post, "/api/v1/generate-pdf", payload);
using Stream stream = await anvil.RequestRestStreamAsync(HttpMethod.Get, "/api/document-group/eid.zip");

// Query string parameters, and the checked HttpResponseMessage for anything else
var response = await anvil.SendRestAsync(HttpMethod.Post, "/api/v1/fill/eid.pdf",
    content: () => new StringContent("{\"data\":{\"name\":\"Sally\"}}", Encoding.UTF8, "application/json"),
    query: new Dictionary<string, string> { ["versionNumber"] = "-1" });

RequestRestAsync throws InvalidOperationException when the response isn't JSON; use the bytes or stream variant for a PDF or zip.

Static methods

PrepareGraphQLFile

Prepares a file for a multipart upload with a GraphQL mutation, per the GraphQL multipart request spec. The result goes anywhere in a mutation's variables under a file key: a DocumentUpload in CreateEtchPacketAsync, or the $file: Upload! of a mutation sent with RequestGraphQLAsync.

// A file on disk; the filename defaults to the file's name
var upload = AnvilClient.PrepareGraphQLFile("/path/to/file.pdf");

// Bytes or a stream, with a filename. The mimetype is guessed from it when not given.
var upload = AnvilClient.PrepareGraphQLFile(bytes, "file.pdf");
var upload = AnvilClient.PrepareGraphQLFile(stream, "file.pdf", "application/pdf");

var data = await anvil.RequestGraphQLAsync(@"
    mutation CreateCast($title: String, $file: Upload!, $isTemplate: Boolean) {
      createCast(title: $title, file: $file, isTemplate: $isTemplate) { eid title }
    }",
    new { title = "My template", file = upload, isTemplate = true });

A request is sent again after a 429 (see Rate limits): a path is reopened and a seekable stream rewound, while a stream that can't seek fails the retry with an error, so prefer a path or bytes. The caller's stream is not disposed.

For a small file, a Base64Upload (Data, Filename, Mimetype) is sent inline in the JSON instead.

Options

AnvilClientOptions:

  • ApiKey - your API key. See Authentication.
  • AccessToken - an OAuth access token, instead of an API key.
  • BaseUrl - the environment to use. Defaults to production. See BaseUrl.
  • UserAgent - the User-Agent header. Defaults to dotnet-anvil/{version}.
  • RequestLimit, RequestLimitMs - the rate limit to start with, until the API's arrives. Defaults to 1 per 1000ms. See Rate limits.
  • Timeout - how long to wait for a response, per request. Defaults to 5 minutes. See Retries.
  • MaxRetries - how many times to retry a 5xx or a connection failure. Defaults to 5. See Retries.
  • HttpClient or HttpMessageHandler - to send requests through your own, e.g. one configured for a proxy, or an IHttpClientFactory client. The client does not dispose an HttpClient you pass in.

Every method also takes a RequestOptions with a Timeout for that request, and a CancellationToken.

Authentication

An API key, from your organization's API settings, is sent as Authorization: Basic base64(apiKey + ":"):

var anvil = new AnvilClient(new AnvilClientOptions { ApiKey = "..." });

When neither ApiKey nor AccessToken is set, the ANVIL_API_KEY environment variable is used.

An OAuth access token, from OAuth, is sent as Authorization: Bearer ...: a JWT as-is, any other token base64 encoded. It takes precedence over an API key.

var anvil = new AnvilClient(new AnvilClientOptions { AccessToken = "..." });
BaseUrl

Every request derives from BaseUrl, which defaults to production, https://app.useanvil.com: REST requests go to {BaseUrl}/api/v1/..., GraphQL requests to {BaseUrl}/graphql and document downloads to {BaseUrl}/api/document-group/.... To use another environment:

var anvil = new AnvilClient(new AnvilClientOptions
{
    ApiKey = "...",
    BaseUrl = "https://<your-environment-url>",
});

Don't include a trailing slash. A full URL given to RequestRestAsync is accepted if it is on the base URL, and refused otherwise, so your credentials never go to another host.

Constants

  • AnvilClient.VERSION_LATEST (-1) - with FillPdfAsync, fills the latest version of the template, published or not. Use it to fill a draft.
  • AnvilClient.VERSION_LATEST_PUBLISHED (-2) - fills the latest published version. This is the default when no version is given, except that it is an error when the template has never been published.

Errors

An error response throws AnvilClientException: any status outside 2xx, a 2xx GraphQL response with errors, or a response that isn't the JSON it claims to be. A request that could not be made at all throws the underlying HttpRequestException, and one that got no response in time a TimeoutException.

try
{
    await anvil.FillPdfAsync("pdf-template-eid", new { });
}
catch (AnvilClientException e)
{
    // "400: ValidationError: Invalid request (data: Required)"
    Console.WriteLine(e.Message);
    Console.WriteLine(e.StatusCode);                 // 400; 0 when there was no response
    foreach (var error in e.Errors)                  // the normalized errors, at least one
    {
        Console.WriteLine($"{error.Name}: {error.Message}");
        foreach (var field in error.Fields)          // field-level details of a validation error
        {
            Console.WriteLine($"  {field.Property}: {field.Message}");
        }
    }
    var headers = e.Headers;          // the response's headers
    var content = e.ResponseContent;  // the body, or the start of a large non-JSON body
    var data = e.ResponseData;        // any `data` a GraphQL response returned alongside its errors
}

The errors are normalized from the API's shapes: a GraphQL response's errors as they are (each error's other members, like path, are in Raw), a REST error's { name, message, fields } as one error, and a non-JSON error, like a 502 from a proxy, as one error named after the status text with the start of the body.

Rate limits

The API rate limits requests per API key, and tells the client the limit in the X-RateLimit-Limit and X-RateLimit-Interval-Ms headers of every response. The client learns it from the first response, holding any concurrent requests until that response arrives, then counts requests over a sliding window the way the API does and only waits when the limit has been reached, so the API never has to answer 429. Every AnvilClient in the process with the same BaseUrl and credentials shares one limiter. RateLimit is the current limit and whether it came from the API.

Should the API answer 429 anyway (another process using the same API key at the same time can cause it), the request is retried after the response's Retry-After plus 50ms, or after a second when there is none, for as long as it takes. The RateLimited event is raised for each.

RequestLimit and RequestLimitMs are the limit to start with, used only until the first response. They default to 1 per second; set them to your account's limit to avoid that first second of pacing.

Retries

Every request is retried on 500, 502, 503 and 504, and when it couldn't connect, up to MaxRetries times (5) with exponential backoff from 100ms, or after the response's Retry-After. Set MaxRetries to 0 to turn it off.

A request that was sent but got no response within Timeout (5 minutes) throws TimeoutException and is not retried, since the API may have processed it. Pass a RequestOptions { Timeout = ... } to a method to override the timeout for that request.

Upgrading from 0.x

1.0 replaces the pre-1.0 RestClient and GraphQLClient with one AnvilClient, and removes the old API. Every method is async, returns a typed result, and throws an AnvilClientException on an error response.

0.x 1.0
new RestClient(apiKey), new GraphQLClient(apiKey) new AnvilClient(apiKey), one client for both
BaseClient AnvilClient
RestClient.FillPdf(id, payload) returns a Stream FillPdfAsync(id, payload) returns byte[]; FillPdfStreamAsync a Stream
RestClient.FillPdf(id, payload, destFile) FillPdfToFileAsync(id, payload, path)
RestClient.FillPdf(id, payload, versionNumber) FillPdfAsync(id, payload, versionNumber)
RestClient.GeneratePdf(payload) returns HttpContent GeneratePdfAsync(payload) returns byte[]; GeneratePdfStreamAsync, GeneratePdfToFileAsync
RestClient.DownloadDocuments(eid) DownloadDocumentsAsync(eid); DownloadDocumentsStreamAsync, DownloadDocumentsToFileAsync
RestClient.SendGetRequest(uri), SendPostRequest(uri, content) RequestRestAsync, RequestRestBytesAsync, RequestRestStreamAsync, SendRestAsync
GraphQLClient.SendQuery(query, variables) returns the whole response RequestGraphQLAsync(query, variables) returns its data and throws on errors
GraphQLClient.CreateEtchPacket(payload) CreateEtchPacketAsync(payload) returns an EtchPacket
GraphQLClient.GetEtchPacket(eid) GetEtchPacketAsync(eid) returns an EtchPacket
GraphQLClient.GenerateEtchSignUrl(signerEid, clientUserId) GenerateEtchSignUrlAsync(signerEid, clientUserId) returns the URL
GraphQLClient.ForgeSubmit(payload) ForgeSubmitAsync(payload) returns a Submission
GraphQLClient.RemoveWeldData(eid) RemoveWeldDataAsync(eid) returns a bool
GraphQLClient.GetCurrentUser() GetCurrentUserAsync() returns a User
ClientConstants.VERSION_LATEST, VERSION_LATEST_PUBLISHED AnvilClient.VERSION_LATEST, VERSION_LATEST_PUBLISHED
Anvil.Queries.* Anvil.GraphQL.Operations

The payloads move from Anvil.Payloads.Request and Anvil.Payloads.Request.Types to Anvil.Payloads, with every option the API documents:

0.x 1.0
Request.FillPdf FillPdfPayload
Request.GeneratePdf with a list of GeneratePdfItem and GeneratePdfTable GeneratePdfPayload with a list of MarkdownContent
Request.Types.GeneratePdfTableContent, the Table of a GeneratePdfTable MarkdownTable, the Table of a MarkdownContent
Request.GeneratePdf with GeneratePdfHtml GeneratePdfPayload with HtmlContent
Request.Types.IGeneratePdfData, IGeneratePdfListable None: GeneratePdfPayload.Data is a list of MarkdownContent, or an HtmlContent
Request.CreateEtchPacket CreateEtchPacketPayload
Request.ForgeSubmit ForgeSubmitPayload
Request.Types.EtchSigner, SignerField, SignatureField, Rect EtchSigner, SignerField, SignatureField, Rect
Request.Types.EtchCastRef, DocumentUpload, DocumentMarkup, DocumentMarkdown The same names in Anvil.Payloads
Request.Types.HtmlCssMarkup, the Markup of a DocumentMarkup HtmlContent
Request.Types.EtchFile, IEtchPacketAttachable Anvil.Types.GraphQL.EtchFile, the base of the file types: CreateEtchPacketPayload.Files is a List<EtchFile>
Request.Types.Base64FileUpload Base64Upload, or a file from PrepareGraphQLFile
Request.GenerateEtchSignUrlPayload, GenerateEtchSignUrlData None: GenerateEtchSignUrlAsync returns the URL as a string

Any object with the right JSON shape works as a payload too: an anonymous object, a dictionary, a JObject or a JSON string. The Anvil.Payloads.Response types are gone: the methods return the generated types in Anvil.Types.GraphQL (EtchPacket, Submission, User).

AnvilClientException.HttpStatusCode is StatusCode (an int, 0 when there was no response), ResponseHeaders is Headers, and the messages that were in Data["Message1"], Data["Message2"], ... are in Errors. Its properties are read-only; ResponseContent could be set before.

Behavior that changed:

  • GraphQL requests go to https://app.useanvil.com/graphql rather than https://graphql.useanvil.com. If a firewall allows only certain hosts, allow app.useanvil.com.
  • The API key is sent as Basic base64(apiKey + ":"), with the trailing colon the other Anvil clients send.
  • The default fields returned by CreateEtchPacketAsync, GetEtchPacketAsync and ForgeSubmitAsync are node-anvil's. documentGroup.id and weldData.id are gone; use eid. Pass a responseQuery to choose the fields.
  • Requests are rate limited and retried (see Rate limits and Retries), and time out after 5 minutes.

Examples

The examples/ project has runnable examples: filling a PDF, generating one from HTML or Markdown, and creating e-sign packets with a template, an embedded signer, and an uploaded PDF.

ANVIL_API_KEY=yourKey dotnet run --project examples -- fill

Development

See CONTRIBUTING.md: building and testing, running every method against a real environment with test-client/, the generated types, and publishing.

Product Compatible and additional computed target framework versions.
.NET net5.0 was computed.  net5.0-windows was computed.  net6.0 was computed.  net6.0-android was computed.  net6.0-ios was computed.  net6.0-maccatalyst was computed.  net6.0-macos was computed.  net6.0-tvos was computed.  net6.0-windows was computed.  net7.0 was computed.  net7.0-android was computed.  net7.0-ios was computed.  net7.0-maccatalyst was computed.  net7.0-macos was computed.  net7.0-tvos was computed.  net7.0-windows was computed.  net8.0 was computed.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed.  net9.0 was computed.  net9.0-android was computed.  net9.0-browser was computed.  net9.0-ios was computed.  net9.0-maccatalyst was computed.  net9.0-macos was computed.  net9.0-tvos was computed.  net9.0-windows was computed.  net10.0 is compatible.  net10.0-android was computed.  net10.0-browser was computed.  net10.0-ios was computed.  net10.0-maccatalyst was computed.  net10.0-macos was computed.  net10.0-tvos was computed.  net10.0-windows was computed. 
.NET Core netcoreapp2.0 was computed.  netcoreapp2.1 was computed.  netcoreapp2.2 was computed.  netcoreapp3.0 was computed.  netcoreapp3.1 was computed. 
.NET Standard netstandard2.0 is compatible.  netstandard2.1 was computed. 
.NET Framework net461 was computed.  net462 was computed.  net463 was computed.  net47 was computed.  net471 was computed.  net472 was computed.  net48 was computed.  net481 was computed. 
MonoAndroid monoandroid was computed. 
MonoMac monomac was computed. 
MonoTouch monotouch was computed. 
Tizen tizen40 was computed.  tizen60 was computed. 
Xamarin.iOS xamarinios was computed. 
Xamarin.Mac xamarinmac was computed. 
Xamarin.TVOS xamarintvos was computed. 
Xamarin.WatchOS xamarinwatchos was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last Updated
1.2.0 104 11/10/2026
1.1.0 97 11/9/2026
1.0.0 151 11/9/2026
0.6.0 15,341 3/3/2026
0.5.0 32,363 9/12/2022
0.4.0 2,342 9/7/2022
0.3.0 2,393 5/23/2022
0.2.0 2,408 3/4/2022
0.1.0-alpha3 375 1/25/2022
0.1.0-alpha2 394 1/20/2022
0.1.0-alpha1 383 1/20/2022
0.1.0-alpha 391 1/20/2022