Anvil 1.2.0
dotnet add package Anvil --version 1.2.0
NuGet\Install-Package Anvil -Version 1.2.0
<PackageReference Include="Anvil" Version="1.2.0" />
<PackageVersion Include="Anvil" Version="1.2.0" />
<PackageReference Include="Anvil" />
paket add Anvil --version 1.2.0
#r "nuget: Anvil, 1.2.0"
#:package Anvil@1.2.0
#addin nuget:?package=Anvil&version=1.2.0
#tool nuget:?package=Anvil&version=1.2.0

dotnet-anvil
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.
- PDF filling API - fill out a PDF template with a web request and structured JSON data.
- PDF generation API - send markdown or HTML and Anvil will render it to a PDF.
- Etch e-sign with API - customizable, embeddable, e-signature platform with an API to control the signing process end-to-end.
- 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:
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 or UrlUpload
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.
For a file at a public http or https URL, a UrlUpload (Url, and optionally Filename) has Anvil download it, so the file never passes through your app:
File = new UrlUpload { Url = "https://example.com/contract.pdf", Filename = "contract.pdf" },
Without a Filename, Anvil takes it from the download's Content-Disposition header or the URL.
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- theUser-Agentheader. Defaults todotnet-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 a5xxor a connection failure. Defaults to 5. See Retries.HttpClientorHttpMessageHandler- to send requests through your own, e.g. one configured for a proxy, or anIHttpClientFactoryclient. The client does not dispose anHttpClientyou 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) - withFillPdfAsync, 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/graphqlrather thanhttps://graphql.useanvil.com. If a firewall allows only certain hosts, allowapp.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,GetEtchPacketAsyncandForgeSubmitAsyncare node-anvil's.documentGroup.idandweldData.idare gone; useeid. Pass aresponseQueryto 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 | Versions 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. |
-
.NETStandard 2.0
- Newtonsoft.Json (>= 13.0.4)
-
net10.0
- Newtonsoft.Json (>= 13.0.4)
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 |