US 1099 Reporting, Automated End to End
An asset manager's US tax-form reporting — 1099-B, 1099-DIV, and the brand-new 1099-DA for digital assets — automated through a third-party filing API: collect the data, send it over HTTPS, generate the PDF and XML, and file to the regulator.
The Problem
US information reporting on Form 1099 is the kind of obligation that is conceptually simple and operationally unforgiving. A firm that holds investments on behalf of US investors has to report the relevant activity to the IRS and furnish copies to the investors: proceeds from sales on 1099-B, dividends on 1099-DIV, and — newly — digital-asset transactions on 1099-DA. Each form has a strict schema, a strict deadline, and consequences that fall on both the firm and the investor if the numbers are wrong.
The client did not generate and transmit these filings directly. As is common, the actual generation and transmission was handled by a specialist third-party filing partner. The firm's job was to collect the right data, get it to the partner correctly, and route the generated output onward. Before this engagement, that hand-off was a manual, per-form effort. The engagement was to build an automation pipeline around it: collect the data, send it to the third party over their HTTPS API, trigger the generation of the PDF and XML, and deliver the result to the regulator or back to the client.
The 1099-B and 1099-DIV flows were the tractable part. The schemas were established, the partner's side was mature, and the work was a matter of building a dependable, repeatable pipeline around a known process. That pipeline — collect, validate, send, generate, deliver — became the foundation for everything else.
Then came 1099-DA. Digital-asset reporting was a brand-new requirement — the first year US jurisdiction mandated it — which meant the flow was new for everyone in the chain. It was new for the firm, new for us, and new for the third-party filing partner, who had to build their side of a form that had never existed before. A first-year regulatory filing, against a hard deadline, on an integration where the partner's own pipeline was still under construction, is precisely the situation where moving fast and automatically is the dangerous option.
The Constraints
- IRS deadlines do not move. 1099 filing dates are fixed. The pipeline had to be dependable against an external calendar, and the first 1099-DA cycle had a hard cut-off that arrived whether or not every system in the chain was ready.
- 1099-DA was first-year, for everyone. There was no established flow to copy — not on our side and not on the filing partner's. Most of the friction during the build traced back to the third-party filing partner building a brand-new digital-asset pipeline in parallel with ours.
- A third party on the critical path. PDF and XML generation happened at the partner. Our automation could not get ahead of a partner whose own side of the new form was unfinished.
- Correctness outranks automation. A wrong first-year filing carries regulatory and client-facing consequences. Where the automated path was not yet proven, the right answer was a controlled manual filing — not an unproven automatic one.
- Sensitive data, secure transport. Investor tax data moves to the filing partner over an authenticated HTTPS API, with the handling discipline that investor-level financial data requires.
The Architecture
The pipeline is a straight line with a third party in the middle. Source data for a given form is collected and validated, built into the agreed payload, and sent to the third party over their HTTPS API, which generates the two outputs — a PDF and an XML file. The generated output is delivered onward — to the regulator or back to the client. All three forms — 1099-B, 1099-DIV, 1099-DA — share this path; a form type is a parameter, not a separate system.
Treating the form type as a parameter rather than a separate pipeline is what made the messy part manageable. Because 1099-B and 1099-DIV already exercised the collect-send-generate-deliver path end to end, adding 1099-DA was — on our side — mostly a matter of the new form's data shape and the partner's new endpoints. The unknowns were concentrated where they actually lived: in a first-year form and in a third party building their half of it at the same time we built ours.
Implementation Highlights
Collect, Send, Generate
The heart of the pipeline is the hand-off to the filing partner: the prepared data is sent to the third party over their HTTPS API, which turns it into the two outputs — a PDF and an XML file. Keeping the send behind one gateway means the rest of the pipeline does not need to know anything about the partner's API — it asks for a generation and gets back a handle it can track.
public sealed class ThirdPartyFilingGateway
{
private readonly HttpClient _http; // HTTPS connection to the third-party filing API
private readonly ILogger<ThirdPartyFilingGateway> _log;
// Send the prepared 1099 data over the third party's HTTPS API,
// which generates the two outputs — a PDF and an XML file.
public async Task<GenerationHandle> SubmitForGenerationAsync(
FilingFile file, CancellationToken ct)
{
using var payload = new ByteArrayContent(file.Content);
payload.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var response = await _http.PostAsync(
$"/v1/filings/{file.FormType}/generate", payload, ct);
response.EnsureSuccessStatusCode();
_log.LogInformation("Sent {Form} filing over HTTPS for PDF + XML generation", file.FormType);
return await response.Content.ReadFromJsonAsync<GenerationHandle>(cancellationToken: ct)
?? throw new InvalidOperationException("Third party returned no generation handle.");
}
}A Deliberate Manual Fallback for 1099-DA
The most important engineering decision on this project was a decision not to automate — yet. For the first 1099-DA cycle, the data was collected and prepared by the pipeline exactly as for the other forms, but the submission itself was handed to the client's team to file by hand, because the automated third-party path for a form that had never existed before was not yet proven. That choice was expressed in the model as a per-form filing mode, so the same cycle code runs both the fully automated forms and the data-only one without special cases scattered through the pipeline.
// How a given 1099 form is filed for a cycle.
public enum FilingMode
{
FullyAutomated, // collect → send → generate → file, no human step
DataOnlyManualSubmit // collect + prepare; client team performs the submission
}
public async Task RunCycleAsync(FormType form, FilingMode mode, CancellationToken ct)
{
var data = await _collector.CollectAsync(form, ct); // always automated
var file = _builder.Build(form, data);
switch (mode)
{
case FilingMode.FullyAutomated:
var handle = await _thirdParty.SubmitForGenerationAsync(file, ct);
await _thirdParty.AwaitGenerationAsync(handle, ct);
await _delivery.FileToRegulatorAsync(handle, ct);
break;
// First 1099-DA cycle: we prepare the data, the client team files it,
// because the automated path for a brand-new form was not yet proven.
case FilingMode.DataOnlyManualSubmit:
await _delivery.HandToClientAsync(file, ct);
break;
}
}
When the third party completed their digital-asset side after the deadline, switching 1099-DA on
was a matter of moving it from DataOnlyManualSubmit
to FullyAutomated
and validating the now-complete path end to end — not rewriting the pipeline.
The Outcome
The 1099-B and 1099-DIV pipelines do what they were built to do: collect the data, send it to the third party over their HTTPS API, generate the PDF and XML, and route the output to the regulator or the client without manual handling. The first-year 1099-DA filing was met by a deliberate split — the pipeline prepared the data, the client's team performed the submission — which removed the risk of betting a brand-new regulatory deadline on an integration that neither side had finished.
Once the regulator's submission window closed and the third party had completed their digital-asset side, the automated 1099-DA path was finished and validated against the now-complete partner pipeline. From the next cycle, all three forms file the same automated way — and the same collect-send-generate-deliver pattern is ready for whatever the next 1099 variant turns out to be.
What We'd Do Differently
The decision to file the first 1099-DA cycle manually was correct, and we would make it again — a hard, first-year regulatory deadline is not the place to debut an unproven automated path. What we would change is how early and how explicitly we pinned down the dependency on the filing partner. Most of the project's friction came from the third-party filing partner building their digital-asset side in parallel with ours, and that critical-path risk was visible from the start. We would have pushed harder, sooner, for contract tests or a sandbox against their new endpoints, so the gaps surfaced in week two rather than close to the deadline.
We would also have built the automated 1099-DA path behind its filing-mode switch from day one and treated the manual submission as the fallback, rather than building the fallback first and the automation after the deadline. The end state is identical, but framing it that way would have let us flip 1099-DA to fully automated the moment the partner was ready, instead of finishing the automated path as a follow-on once the pressure was off.
If You're Solving This Today
When a third party sits on your critical path for a first-year obligation, design for their unreadiness explicitly: make the manual-versus-automated choice a first-class, per-item switch, and invest early in being able to test against their side before it is finished. The same staged-rollout instinct shows up in our proxy voting automation, where proving one flow in production before adding the next was the way we kept a deadline-bound process safe.
Related Case Studies
Questions about 1099 reporting automation.
- Which 1099 forms does the pipeline cover?
- Three: 1099-B (proceeds), 1099-DIV (dividends), and the new 1099-DA for digital-asset transactions. All three run through the same pipeline — collect the source data, send it to a third-party filing partner over an HTTPS API, generate the two outputs (a PDF and an XML file), and route the result to the regulator or back to the client.
- Why was the first 1099-DA cycle filed manually?
- 1099-DA was the first year US jurisdiction required digital-asset reporting, so the flow was new for everyone — including the filing partner, who was still building their side. Rather than bet a hard regulatory deadline on an unproven automated path, we collected and prepared the data with the pipeline but had the client's team perform the submission. Once the deadline passed and the partner finished their side, the automated path was completed and validated for the next cycle.
- What does the third-party filing integration do?
- A specialist third party generates and transmits the filings. The pipeline sends the prepared data to them over an HTTPS API, which generates the two required outputs — a PDF and an XML file; the generated output is then filed to the regulator or returned to the client. Adding a new form type reuses the same send-and-generate path.
A New Regulatory Filing Landing on a Hard Deadline?
The fastest way to assess the risk is a two-week Discovery Sprint — a fixed-price diagnostic that maps your data flow, the third-party integration points, and the filing timeline before you commit to anything.