Demo preview. IrisTaxFiling runs in test mode against an IRS simulator. Registrations are welcome.Register for early access

Information returns, as an API

Your tax software shouldn’t have to become tax infrastructure.

IrisTaxFiling helps software companies validate, prepare, submit, track, and correct U.S. information returns through a developer-first API.

Built for SaaS platforms, marketplaces, payroll systems, accounting software, and high-volume filers.

One API. 37 IRIS forms. Zero IRS plumbing.

REST + JSONOpenAPI 3.1Idempotency-Keydry-run validateHMAC-signed webhooksproblem+json errorsCSV templatesFIRE importtest modeAES-256-GCM at restedge-deployedCLI

Don’t build the IRS integration yourself.

Your platform already owns the customer, vendor, payment, and tax data. The painful part is everything between that data and a successful filing.

  1. Your data
  2. Tax mapping
  3. Validation
  4. IRS schemas
  5. Submission
  6. Acknowledgements
  7. Corrections
  8. Audit trail

IrisTaxFiling handles the infrastructure layer.

Filing isn’t just an API call.

High-volume filing is a lifecycle. Every stage below is something your team would otherwise build, run, and keep current.

Data normalizationForm mappingSchema validationBusiness-rule validationSubmission orchestrationIdempotencyRetry handlingIRS acknowledgementsRejection handlingCorrectionsAudit historyFiling statusOperational visibility

Product

Everything between your tax data and the IRS.

01 Ingest

Bring your existing tax data.

Send records without reshaping your data model first.

JSON · CSV · database exports · internal systems
02 Validate

Know what’s going to fail before you submit.

Schema and business-rule checks with field-level errors.

warnings and blockers
03 Submit

Reliable filing infrastructure.

IRIS-ready preparation and submission orchestration.

retries · idempotency · acknowledgement tracking
04 Resolve

Turn rejection into an actionable workflow.

Explain the error, find affected records, correct, revalidate, resubmit.

correction workflow

Forms

37 IRIS forms. One API.

The full IRIS catalogue is in the API, with IRS template columns, rules and CSV templates for every form. Four forms are fileable end to end in the demo; the rest have the bulk readiness check today.

37IRIS forms in the catalogue
4fileable end to end in the demo
37with CSV template and readiness check
2022 to 2025tax-year specs from the IRS templates

1099 series21 forms

1099-A1099-B1099-C1099-CAP1099-DA1099-DIV1099-G1099-INT1099-K1099-LS1099-LTC1099-MISC1099-NEC1099-OID1099-PATR1099-Q1099-QA1099-R1099-S1099-SA1099-SB

1098 and 1097 series7 forms

1097-BTC10981098-C1098-E1098-F1098-Q1098-T

5498 series4 forms

54985498-ESA5498-QA5498-SA

Other IRIS forms5 forms

1042-S392139228809W-2G
Live in demo: create, validate, submit, correctReadiness check: template, rules and bulk validation (hover for the form name)

What’s in the demo

The whole filing lifecycle, as an API.

Everything below runs today in test mode. We mark what is still in progress or on the roadmap, so you know what you can build against.

Live in demo

Pre-flight validation

Field-level errors with a JSON path, a code and a fix. Blockers stop a filing, warnings do not. Add ?mode=validate for a dry run that stores nothing.

Live in demo

TIN checks

Format rules for SSN, EIN, ITIN and ATIN plus known-invalid patterns. A full TIN is never echoed back. Format only: IRS TIN matching is not part of the demo.

Live in demo

Bulk readiness check

Send the IRS template CSV or JSON rows for any of the 37 forms and get a grouped report with row numbers and fixes. POST /v1/forms/{id}/validate, nothing stored.

Live in demo

Filing lifecycle

Create, submit, read acknowledgements. An explicit state machine (ready, submitted, accepted, rejected, failed) and a queryable status on every filing.

Live in demo

Corrections and replacements

Fix a rejected filing with POST /v1/filings/{id}/corrections. The new filing links to the original, which is marked corrected.

Live in demo

FIRE file import

Convert an IRS Pub 1220 file into filings. Checks payee counts and control totals, reports what it cannot map instead of guessing, and re-uploading the same file creates no duplicates.

Live in demo

Idempotency

Send an Idempotency-Key and retries return the first response. The same key with a different body is a clear 409.

Live in demo

Signed webhooks

Nine events, an HMAC-SHA256 signature with a timestamp, and up to six delivery attempts with backoff. Your product never has to poll.

Live in demo

Test mode with a simulator

Magic TINs and payer names reproduce acceptance, rejection, slow acknowledgements and IRS outages. No IRS, no risk, no real data.

Live in demo

Audit log and usage

Every filing action is recorded and metered per month and mode. GET /v1/audit, GET /v1/usage.

Live in demo

Encryption and rate limits

AES-256-GCM at rest for filing data, generated XML and webhook secrets. Per-account limits with RateLimit-* headers.

Live in demo

Edge-deployed, runs locally too

Cloudflare Workers with Postgres. The same code runs on your laptop with the irisfile CLI: dev, validate, sample, forms, template, check, fire.

Live in demo

OpenAPI and clear errors

An OpenAPI 3.1 spec, application/problem+json errors with stable codes, and copy-paste examples in the docs.

In progress

IRIS A2A transmitter

Implements IRS Pub 5718: OAuth2 JWT-bearer, multipart intake, status polling. So far it has only run against our own protocol sandbox, not the IRS.

Roadmap

Real IRS filing

Needs an IRIS TCC, an API client certificate, the IRS schema package and a pass on the IRS test system. Until then the XML is provisional and live mode is off.

Use cases

Built for software that generates tax data.

Pick your platform. Each scenario shows what you send, what comes back and what works in the demo today.

Year-end 1099-NEC for every contractor you paid.

You pay thousands of contractors through your platform. In January you need a clean 1099-NEC for each one, and a plan for the ones the IRS bounces.

  1. Map payouts to recipients[].nonemployee_compensation.
  2. Dry-run the batch to catch bad TINs and states in December, not January.
  3. Create and submit with an Idempotency-Key per payer.
  4. Listen for filing.rejected and send a replacement with one call.
1099-NEC1099-MISC

In the demo today: the full lifecycle against the IRS simulator, including rejection and correction.

POST /v1/filings?mode=validate

{ "form": "1099-NEC", "tax_year": 2026,
  "payer": { "name": "Acme Platforms Inc", "tin": "12-3456789", ... },
  "recipients": [{
    "name": "Jane Contractor",
    "tin": "123-45-6781",
    "nonemployee_compensation": 12500.50
  }] }

→ { "status": "valid", "summary": { "blockers": 0 } }

Seller and creator payouts, reported at scale.

A marketplace pays out to sellers and creators. Some reach payment-network thresholds, others are plain service payments. You need to sort them, check the data and file.

  1. Download the IRS CSV template for the form you need.
  2. Run the bulk readiness check on your export and get row-level problems.
  3. File the 1099-NEC and 1099-MISC population through the API.
1099-NEC1099-MISC1099-K

In the demo today: 1099-NEC and 1099-MISC filing, plus the template and bulk readiness check for 1099-K. Full 1099-K filing is on the roadmap.

curl -X POST https://api.iristaxfiling.com/v1/forms/1099-K/validate \
  -H "Authorization: Bearer $IRISTAXFILING_KEY" \
  -H "Content-Type: text/csv" \
  --data-binary @sellers.csv

→ { "object": "readiness", "status": "blocked",
     "summary": { "records": 25000, "blocked_records": 312 } }

Information-return filing inside your own product.

You run payroll, HR or accounting software. Your customers expect 1099s to just work, and your engineers do not want to learn IRS transmission.

  1. Create a filing per customer (payer) from the data you already hold.
  2. Show validation issues in your UI with the field path and the suggested fix.
  3. Register a webhook and update status without polling.
  4. Keep the audit trail and usage per account.
1099-NEC1099-MISCW-2G1099-G

In the demo today: webhooks with signature verification, audit log and usage metering. W-2G and 1099-G are readiness-check only.

POST https://your-app.example/hooks/irisfile
IrisFile-Signature: t=1791640000,v1=9f2c...

{ "type": "filing.accepted",
  "livemode": false,
  "data": { "filing": { "id": "fil_...", "status": "accepted" } } }

Interest and dividends for every account holder.

A bank, credit union or investment app reports interest and dividends. Foreign tax paid, bond CUSIPs and qualified-dividend splits all have to line up.

  1. Send box amounts in recipients[].amounts and text boxes in details.
  2. Rules catch a portion larger than its total (for example qualified dividends over ordinary dividends).
  3. Submit, track and correct like any other filing.
1099-INT1099-DIV1099-OID10981099-B

In the demo today: 1099-INT and 1099-DIV filing. 1099-OID, 1098 and 1099-B are readiness-check only.

{ "form": "1099-INT", "tax_year": 2026,
  "recipients": [{
    "name": "Alex Saver", "tin": "123-45-6781",
    "amounts": { "interest_income": 842.17,
                 "federal_tax_withheld": 0,
                 "foreign_tax_paid": 3.50 },
    "details": { "foreign_country": "CA" }
  }] }

Rents and vendor payments, every year, no spreadsheets.

Property managers report rents paid to owners and fees paid to vendors. The data is recurring, so the filing should be too.

  1. Rents go in 1099-MISC amounts.rents, vendor services in 1099-NEC.
  2. Validate the batch whenever data changes, then submit once it is clean.
  3. Replace a filing when a payee changes details.
1099-MISC1099-NEC1099-S1098

In the demo today: 1099-MISC and 1099-NEC filing. 1099-S and 1098 are readiness-check only.

{ "form": "1099-MISC", "tax_year": 2026,
  "recipients": [{
    "name": "Pine Street Holdings", "tin": "98-7654321",
    "tin_type": "ein",
    "amounts": { "rents": 18000, "other_income": 250.75 }
  }] }

Keep your FIRE files. Move to IRIS.

You already produce FIRE flat files. Rather than rebuild the pipeline, point it at the importer and keep going while the IRS moves from FIRE to IRIS.

  1. Upload the Pub 1220 file. Nothing is stored on a dry run.
  2. Review the result: payee counts, control totals, what was skipped and why.
  3. Re-upload with ?create=true to create the filings. Sending the same file again creates nothing twice.
1099-NEC1099-MISC1099-INT1099-DIV

In the demo today: import for the four forms above. Other forms and G/C corrections are reported as skipped, not guessed.

curl -X POST "https://api.iristaxfiling.com/v1/imports/fire?create=true" \
  -H "Authorization: Bearer $IRISTAXFILING_KEY" \
  --data-binary @fire.txt

→ { "object": "fire_import", "created": true,
     "summary": { "issuers": 3, "payees": 3, "imported": 2, "skipped": 1 } }

Retirement, health and equity forms.

Plan administrators, HSA providers and equity platforms deal with forms that are not on the first-wave list: distributions, contributions, stock plans.

  1. Download the CSV template for the form from the API.
  2. Run the bulk readiness check on your export.
  3. Fix the grouped problems with row numbers and re-check.
1099-R1099-SA54985498-SA392139221099-Q

In the demo today: catalogue, template and bulk readiness check for all 37 forms. Full filing for these forms is on the roadmap.

GET /v1/forms/3922/template      → text/csv
POST /v1/forms/3922/validate     → readiness report

curl https://api.iristaxfiling.com/v1/forms/3922 \
  -H "Authorization: Bearer $IRISTAXFILING_KEY"

Filing readiness

Fix issues before they become filing failures.

Interactive prototype using synthetic data. No live IRS transmission occurs from this demo.

filing readinesssynthetic data
file
2026_1099_batch.csv
records
102,481
tax year
2026
form
1099-NEC
Records0
Ready0
Warnings0
Blockers0
StatusBLOCKED UNTIL FIXED
blockers139 total
Invalid recipient TIN73
Missing recipient information41
Invalid state combination25

Each blocker links to the affected records, so corrections can be revalidated and resubmitted.

Developer-first by design

Bring your data. IrisTaxFiling handles the filing infrastructure.

Your engineers shouldn’t have to become experts in IRS transmission formats, filing workflows, and correction mechanics.

requestPOST /v1/filings?mode=validate
curl -X POST "https://api.iristaxfiling.com/v1/filings?mode=validate" \
  -H "Authorization: Bearer $IRISTAXFILING_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "form": "1099-NEC",
  "tax_year": 2026,
  "payer": { ... },
  "recipients": [{
    "name": "Jane Contractor",
    "tin": "000-00-0000",
    "address": { ..., "state": "ZZ" },
    "nonemployee_compensation": 12500.50
  }]
}'
response200 OK · nothing stored
{
  "object": "validation",
  "status": "blocked",
  "summary": { "blockers": 2, "warnings": 0 },
  "issues": [
    { "code": "tin_invalid",
      "path": "recipients[0].tin",
      "fix": "Verify the TIN with the recipient and correct it." },
    { "code": "state_invalid",
      "path": "recipients[0].address.state",
      "fix": "Use a 2-letter US state ... e.g. TX." }
  ]
}

Not another tax filing dashboard.

Traditional tax filing software

  • User-facing tax workflows
  • Manual filing experience
  • Form-centric
  • Built for individual businesses

IrisTaxFiling

  • API-first
  • Embedded into existing software
  • Data-centric
  • Built for software companies
  • High-volume workflows
  • Filing lifecycle control
  • Developer-first

FIRE to IRIS

FIRE is changing. Your infrastructure has to change with it.

The IRS is transitioning information-return filing from the legacy FIRE system to IRIS. For software companies that have built or depend on filing infrastructure, this creates a significant migration and integration requirement.

Move from legacy filing workflows without rebuilding everything.

Keep your existing data model. Let IrisTaxFiling handle the translation, validation, and filing workflow.

  1. Legacy data: CSV / FIRE / internal system
  2. IrisTaxFiling
  3. Normalize
  4. Validate
  5. IRIS-ready
  6. Submit

Developer experience

Five minutes to your first filing workflow.

  1. Register for a test key
  2. Send sample filing
  3. Validate
  4. Review
  5. Submit
curl https://api.iristaxfiling.com/v1/filings \
  -H "Authorization: Bearer $IRISTAXFILING_KEY" \
  -H "Idempotency-Key: 2026-nec-0001" \
  -d @filing.json

Examples use plain HTTP. Official SDKs are planned.

Your system stays in control.

Webhooks report every state change, so your product never has to poll.

filing.createdfiling.validatedfiling.readyfiling.submittedfiling.acceptedfiling.rejectedcorrection.requiredfiling.corrected

Reliability

Built for filing deadlines.

Live in demo

Idempotent submissions

Safe to retry without duplicate filings, for API calls and for re-uploaded FIRE files.

Live in demo

Retry handling

Webhook deliveries are retried with backoff. A failed transmission is marked failed and can be submitted again.

Live in demo

Submission state tracking

Every filing has an explicit, queryable state and a one-minute background check for acknowledgements.

Live in demo

Acknowledgement storage

IRS responses are kept with the filing, with the field path of each error.

Live in demo

Correction workflows

Corrections and replacements link back to the original filing.

Live in demo

Operational alerts

Failed acknowledgement checks and abandoned webhooks raise an alert, with Slack or Teams delivery.

Live in demo

Audit trails

Filing actions are recorded per account and readable through the API.

Roadmap

Durable queues

Submissions run on a scheduler today. Queue-based workers are planned for spikes and long outages.

Security

Security designed for sensitive tax data.

Live in demo

Encryption

TLS in transit. AES-256-GCM at rest for filing data, generated XML and webhook secrets.

Live in demo

TIN handling

TINs are masked in API responses and never echoed back in full.

Live in demo

Test and live separation

Separate keys and separate data for test and live mode. Live submission is off until IRS access is in place.

Live in demo

Audit logging and rate limits

Filing actions are logged. Per-account request limits protect the API.

Live in demo

Signed webhooks

Every delivery carries a timestamped HMAC signature you can verify.

Roadmap

Role-based access

Least-privilege roles for people and keys. Keys are account-wide today.

Roadmap

Key management

A managed key service and rotation. Today one data key encrypts at rest.

Roadmap

Data retention controls

Configurable retention and purge for filing data.

This is a demo deployment: do not send real taxpayer data. Compliance requirements vary by data source, customer role, and filing workflow. IrisTaxFiling does not provide legal or tax advice.

Pricing

API pricing that scales with filing volume.

Developer

$199/month

For development and early integrations.

  • Sandbox
  • API access
  • Validation
  • Documentation
Start building

Business

$999/month

For production SaaS platforms.

  • Production API
  • Webhooks
  • Corrections
  • Audit trail
Talk to us

Enterprise

Custom

For high-volume filing infrastructure.

  • High-volume filing
  • Enterprise controls
  • Dedicated support
Talk to us

Usage-based filing volume is a secondary pricing dimension. Prices are illustrative and not final.

Built for the infrastructure problem behind information returns.

API-firstIRIS-ready architectureValidation engineEvent-driven workflowAuditability

Early access

We’re in demo. Registrations are welcome.

IrisTaxFiling is a working demo in test mode: filings run against a simulator, not the IRS. Tell us what you want to file and we’ll get in touch.

We use this only to contact you about IrisTaxFiling. No account is created and nothing is filed.

Build your product. Let IrisTaxFiling handle the filing infrastructure.

Connect your existing tax data to a developer-first filing workflow.

hello@iristaxfiling.com