# ANAF e-Factura (npm · @foreverworks/mcp-anaf-efactura)

Read, check and file a Romanian company's e-invoices and e-Transport declarations with ANAF.

- Trust score: 83/100 (high trust)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- npm · `@foreverworks/mcp-anaf-efactura`: 83/100 (this document), [markdown](https://verifymcp.io/servers/com-foreverworks-anaf-efactura/foreverworks-mcp-anaf-efactura.md), [page](https://verifymcp.io/servers/com-foreverworks-anaf-efactura/foreverworks-mcp-anaf-efactura)

## Channel facts

- Registry: `npm`
- Package: `@foreverworks/mcp-anaf-efactura`
- Version: `0.1.1`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 99/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 7 of 31 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to foreverworks/mcps).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 4 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 62/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4774 tokens (~238/item across 20 items; 20 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 33/100
  - Stability observed for 10 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 96/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 87% of tool parameters carry a description.
  - Structured output schemas are declared (10% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 20 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 21 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the ANAF e-Factura MCP server?

ANAF e-Factura runs locally as an npm package, launched with npx -y @foreverworks/mcp-anaf-efactura. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add com-foreverworks-anaf-efactura -- npx -y @foreverworks/mcp-anaf-efactura
```

### Cursor

```json
{
  "mcpServers": {
    "com-foreverworks-anaf-efactura": {
      "command": "npx",
      "args": [
        "-y",
        "@foreverworks/mcp-anaf-efactura"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-foreverworks-anaf-efactura": {
      "command": "npx",
      "args": [
        "-y",
        "@foreverworks/mcp-anaf-efactura"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add com-foreverworks-anaf-efactura -- npx -y @foreverworks/mcp-anaf-efactura
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-foreverworks-anaf-efactura": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@foreverworks/mcp-anaf-efactura"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-foreverworks-anaf-efactura --command npx --arg -y --arg @foreverworks/mcp-anaf-efactura
```

### Hermes

```yaml
mcp_servers:
  com-foreverworks-anaf-efactura:
    command: "npx"
    args: ["-y", "@foreverworks/mcp-anaf-efactura"]
```

### Netclaw

```json
{
  "McpServers": {
    "com-foreverworks-anaf-efactura": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@foreverworks/mcp-anaf-efactura"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-foreverworks-anaf-efactura -t stdio -c npx -a -y @foreverworks/mcp-anaf-efactura
```

### Other

```json
{
  "mcpServers": {
    "com-foreverworks-anaf-efactura": {
      "command": "npx",
      "args": [
        "-y",
        "@foreverworks/mcp-anaf-efactura"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-04 (score 83, +1)

No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-02 (score 82, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-01 (score 81, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-31 (score 66, −14)

- [security regression] Malware scan: pass → unverified
- [functional] Package version: 0.1.0 → 0.1.1

### 2026-10-28 (score 80, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-26 (score 79)

First indexed and scored.

## MCP tools (20)

### `begin_authorization` (~108 tokens)

Begin ANAF authorization

Start (re)authorizing this server with ANAF when the grant is dead or about to end. Returns authorizeUrl for the CERTIFICATE HOLDER to open in a browser with the qualified digital certificate; you cannot do that step. Then call complete_authorization with the address the browser lands on, within 60 seconds of it landing. Starting again replaces an earlier begun authorization.

Input parameters:

- `redirect_uri` (string): One of the redirect URIs registered in app.json. Empty means the first one.

### `build_invoice` (~527 tokens)

Build a CIUS-RO invoice

Write a Romanian e-Factura invoice (UBL 2.1, CIUS-RO) from fields: seller and buyer, lines with their net price, quantity and VAT category, the currency, the payment terms. Totals are computed exactly (each line rounded to 2 decimals, VAT once per category and rate), and the draft is checked first: CIF, CNP and IBAN check digits, the county and Bucharest sector, the VAT rules per category, CIUS-RO's lengths, every problem named at once. The file goes to the outbox; the answer gives its path, sha256 and totals. Nothing is sent to ANAF: next, validate_invoice with xml: { path }, then upload_invoice with the same path to file it. An invoice in another currency needs vat_exchange_rate (RON per unit), so its VAT is stated in RON too.

Input parameters:

- `buyer` (object, required): The buyer.
- `buyer_reference` (string)
- `contract_reference` (string)
- `currency` (string): ISO 4217, RON by default.
- `delivery_date` (string)
- `due_date` (string): When payment is due; an amount due needs this or payment terms.
- `file_name` (string): The file's name in the outbox; by default the invoice number's.
- `invoice_period` (object)
- `issue_date` (string, required)
- `lines` (array, required)
- `notes` (array)
- `number` (string, required): The invoice number, series included; it must contain a digit.
- `order_reference` (string)
- `payment` (object)
- `preceding_invoice` (object): The invoice this one corrects or reverses.
- `save_dir` (string): A folder INSIDE the outbox (e.g. "2026-10"); empty means the outbox itself.
- `seller` (object, required): The seller: your company.
- `type_code` (string): 380 invoice (default), 384 corrected, 389 self-billed, 751 for accounting.
- `vat_exchange_rate` (string): For an invoice not in RON, required: RON for one unit of its currency (bnr's rate); the VAT is then also stated in RON.
- `vat_exemptions` (array): Why a category carries no VAT: required for E (a VATEX-EU code or the law's words); AE, G and O default to VATEX-EU-AE, -G, -O.

Output parameters:

- `bytes` (integer)
- `extern` (boolean): The buyer is not Romanian: upload it with extern: true
- `invoice` (object): The file read back the way upload_invoice reads it for its confirmation line
- `path` (string): The built file in the outbox: give it to validate_invoice and upload_invoice as xml: { path }
- `sha256` (string)
- `totals` (object)

### `complete_authorization` (~127 tokens)

Complete ANAF authorization

Finish what begin_authorization started: exchanges ANAF's code for tokens and stores them where this server keeps them. Pass the whole address the browser landed on as redirect_url (or code and state). Answers only the two expiry dates; no token ever appears in the result. ANAF's code dies 60 seconds after it is issued, so call this at once.

Input parameters:

- `code` (string): Only instead of redirect_url.
- `redirect_url` (string): The full address with ?code=...&state=... in it.
- `state` (string): Only with code.

### `download_invoice` (~194 tokens)

Download a signed invoice archive

Download the signed ZIP for a message id from list_invoices and save it to the downloads outbox (a name holding another file gets a number, never overwritten). The archive is checked first: it must open with every entry matching its checksum and hold the document with ANAF's seal (semnatura_*.xml), and the seal is checked against the document. Returns the path, bytes, sha256 and md5 of the archive, each entry's name, bytes and sha256, the seal's verdict, and what the invoice says.

Input parameters:

- `message_id` (string, required): The id field from list_invoices (digits), not requestId.
- `save_dir` (string): A folder INSIDE the downloads outbox (e.g. "2026-09"); empty means the outbox itself. A path outside it is refused.
- `test` (boolean): Query ANAF's test environment instead of production.

### `etransport_file` (~433 tokens)

File an e-Transport declaration

File an e-Transport declaration XML (ANAF's schema v2) with ANAF: a new transport (notificare), its correction (notificare with corectie), a deletion (stergere), a receiver's confirmation (confirmare) or a vehicle change (modifVehicul), whichever the file holds. The XML as xml: { path } for a file, or { content_base64, sha256 } from a script. Goes to ANAF's TEST environment unless test is explicitly false. A money tool (a fiscal declaration): the client asks the user to approve each call, on a line read out of the file (operation, UIT, route, vehicle, goods value in RON, environment). The declarant's code and any UIT must pass their check digits. Returns accepted, the uploadId etransport_status takes and the UIT, or accepted=false with ANAF's reasons; the UIT counts only once etransport_status says ok. The same bytes are not filed in production twice unless refile is true. Needs the ETRANSPORT role on the grant. Moves money or makes a legal document: the client asks the user to approve each call.

Input parameters:

- `cif` (string): The CIF filing it (the declarant's). Defaults to app.json's company_cif.
- `refile` (boolean): File again a declaration whose exact bytes were already sent to production. Refused without it, so a retry after a lost answer cannot file it twice: check etransport_status or etransport_list first.
- `test` (boolean): TRUE by default. Pass false to file with ANAF for real.
- `xml` (object, required): The e-Transport declaration XML (schema v2): { path } or { content_base64, sha256 }. Never type or paste a file's base64 yourself: a retyped file can arrive changed. Give the path of a file in your w…

### `etransport_list` (~130 tokens)

List e-Transport messages

List e-Transport declarations from the last N days (at most 60): UIT code, declarant, trading partner, carrier, vehicle, and refused=true with ANAF's messages for a declaration it rejected. A notice field means ANAF refused or had nothing. Separate from e-Factura: it needs the ETRANSPORT role on the same grant.

Input parameters:

- `cif` (string): Defaults to the CIF in app.json.
- `test` (boolean): Query ANAF's test environment instead of production.
- `zile` (integer): Lookback in days, 1 to 60.

### `etransport_status` (~104 tokens)

Check an e-Transport filing

How an e-Transport declaration filed with etransport_file was processed, by its uploadId: state ok (the UIT is valid from now), processing, or failed with ANAF's reasons. Ask the environment it was filed in: test unless test is false.

Input parameters:

- `id_incarcare` (string, required): The uploadId etransport_file returned: digits.
- `test` (boolean): TRUE by default. Pass false to file with ANAF for real.

### `health` (~59 tokens)

Health

Check that the integration is alive and say so in detail: the ANAF app it authenticates as, the CIF it defaults to, the roles the grant carries, and how many days are left on each token. Run this before concluding the MCP is broken.

### `invoice_pdf` (~307 tokens)

Render an invoice as ANAF's PDF

Have ANAF render an invoice as its official PDF and save it to the downloads outbox. Give message_id (from list_invoices) for a filed invoice, or a UBL document as xml ({ path } for a file, or { content_base64, sha256 } from a script). A filed invoice is not validated again; a document is validated first unless validate is false, and when it fails nothing is saved and findings say why. Returns saved, path, bytes and sha256 of the PDF. The PDF itself needs no grant; fetching a filed invoice by message_id does.

Input parameters:

- `message_id` (string): The id field from list_invoices (digits), not requestId.
- `save_dir` (string): A folder INSIDE the downloads outbox (e.g. "2026-09"); empty means the outbox itself. A path outside it is refused.
- `test` (boolean): For message_id only: fetch it from ANAF's test environment.
- `validate` (boolean): For a document only: validate before converting.
- `xml` (object): A UBL invoice or credit note: { path } or { content_base64, sha256 }. Never type or paste a file's base64 yourself: a retyped file can arrive changed. Give the path of a file in your workspace folder…

### `list_invoices` (~147 tokens)

List e-Factura messages

List e-Factura messages from the last N days (ANAF allows at most 60). Each message has a kind (sent, received, error, buyerMessage), an id that download_invoice takes, a zoneless local timestamp, and details: the upload id, issuer CIF and beneficiary CIF lifted out of ANAF's prose. A notice field means ANAF refused rather than returned nothing.

Input parameters:

- `cif` (string): Defaults to the CIF in app.json. With or without the RO prefix; both are accepted.
- `test` (boolean): Query ANAF's test environment instead of production.
- `zile` (integer): Lookback in days, 1 to 60.

### `list_invoices_window` (~157 tokens)

List e-Factura messages over a date window

List messages over an inclusive YYYY-MM-DD window, paginated, in the same shape as list_invoices plus page counters. The window may span at most 60 days and is read as UTC. filtru narrows by type: E errors, T sent, P received, R awaiting a response.

Input parameters:

- `cif` (string): Defaults to the CIF in app.json. With or without the RO prefix; both are accepted.
- `end_date` (string, required): YYYY-MM-DD, inclusive.
- `filtru` (string): Empty means every type.
- `page` (integer)
- `start_date` (string, required): YYYY-MM-DD, inclusive.
- `test` (boolean): Query ANAF's test environment instead of production.

### `lookup_company` (~148 tokens)

Look up Romanian companies

Look up companies in ANAF's public VAT registry by CIF: name, trade register number, registered office, CAEN code, and the statuses an invoice depends on (vatPayer with its current period, vatOnCollection, splitVat, inactive, and eFacturaRegistry for the RO e-Factura registry). notFound lists the CIFs ANAF does not know. A status ANAF did not report is absent, not false. Needs no grant.

Input parameters:

- `cifs` (array, required): 1 to 100 CIFs, with or without the RO prefix.
- `date` (string): YYYY-MM-DD: the statuses as they stood that day. Empty means today in Bucharest.

### `parse_invoice` (~270 tokens)

Read an invoice as JSON

Read a UBL invoice or credit note into plain JSON: seller and buyer (names, VAT and legal ids, address, contact), every line (quantity, unit, price, net amount, VAT category and rate), the VAT breakdown, the totals, and the payment terms (due date, terms, IBAN). Every value is the document's own text, amounts included, never a number; a field the document does not fill is absent. Give xml ({ path } for a file, or { content_base64, sha256 } from a script) or archive, a .zip download_invoice saved to the outbox. Reads only: nothing goes to ANAF. To have ANAF check the document, use validate_invoice.

Input parameters:

- `archive` (string): A .zip in the downloads outbox, from download_invoice: its name, or its path under the outbox.
- `xml` (object): A UBL invoice or credit note: { path } or { content_base64, sha256 }. Never type or paste a file's base64 yourself: a retyped file can arrive changed. Give the path of a file in your workspace folder…

Output parameters:

- `archive` (object): The archive read, when it came from the outbox
- `file` (object): The file read, when the document came as xml
- `invoice` (object)

### `refresh_token` (~78 tokens)

Refresh the access token

Mint a new access token. Does nothing while the current one still has its three-day cushion unless force is set, because every refresh also ROTATES the refresh token and the old one dies with it. Safe to call on a schedule; pointless to call in a loop.

Input parameters:

- `force` (boolean): Refresh even when the access token has time left.

### `token_status` (~50 tokens)

Token status

Report on the stored OAuth tokens without contacting ANAF and without refreshing. Watch refreshTokenRemainingDays: once it reaches zero the grant can only be restored by hand, at a browser, with the qualified certificate.

### `upload_invoice` (~434 tokens)

Upload an invoice XML

Submit an invoice (UBL or CII XML) to ANAF, given as xml: { path } for a file, or { content_base64, sha256 } from a script. Every IBAN in it must pass its check digits. Goes to the TEST environment unless test is explicitly false, because a production upload is a filing that cannot be recalled. A money tool: the client asks the user to approve each call, on a line read out of the XML itself (number, date, buyer, amount due, the file's sha256). Returns accepted plus the uploadId that upload_status takes, or accepted=false with ANAF's reasons; sha256 and bytes of what was filed; invoice is what the XML says, and raw is ANAF's answer verbatim. The same bytes are not filed in production twice unless refile is true. Moves money or makes a legal document: the client asks the user to approve each call.

Input parameters:

- `autofactura` (boolean): Self-billing on the supplier's behalf.
- `cif` (string): The ISSUER's CIF. Defaults to app.json's company_cif.
- `executare` (boolean): Issued under an enforcement procedure.
- `extern` (boolean): The buyer is foreign and has no Romanian CUI.
- `refile` (boolean): File again a document whose exact bytes were already sent to production. Refused without it, so a retry after a lost answer cannot file the invoice twice: check upload_status or list_invoices first.
- `standard` (string): UBL for an ordinary invoice.
- `test` (boolean): TRUE by default. Pass false to file with ANAF for real.
- `xml` (object, required): The invoice XML (at most 10 MB): { path } or { content_base64, sha256 }. Never type or paste a file's base64 yourself: a retyped file can arrive changed. Give the path of a file in your workspace fol…

### `upload_invoice_b2c` (~417 tokens)

Upload an invoice to a person (B2C)

Submit an invoice issued to a PERSON, not a company (B2C), through ANAF's /uploadb2c: the same as upload_invoice in every other way. The XML as xml: { path } (build_invoice's path works) or { content_base64, sha256 } from a script; every IBAN must pass its check digits. Goes to the TEST environment unless test is explicitly false. A money tool: the client asks the user to approve each call, on a line read out of the XML and marked B2C. Returns accepted plus the uploadId upload_status takes, or accepted=false with ANAF's reasons. The same bytes are not filed in production twice, by either upload tool, unless refile is true. Moves money or makes a legal document: the client asks the user to approve each call.

Input parameters:

- `autofactura` (boolean): Self-billing on the supplier's behalf.
- `cif` (string): The ISSUER's CIF. Defaults to app.json's company_cif.
- `executare` (boolean): Issued under an enforcement procedure.
- `extern` (boolean): The buyer is foreign and has no Romanian CUI.
- `refile` (boolean): File again a document whose exact bytes were already sent to production. Refused without it, so a retry after a lost answer cannot file the invoice twice: check upload_status or list_invoices first.
- `standard` (string): UBL for an ordinary invoice.
- `test` (boolean): TRUE by default. Pass false to file with ANAF for real.
- `xml` (object, required): The invoice XML (at most 10 MB): { path } or { content_base64, sha256 }. Never type or paste a file's base64 yourself: a retyped file can arrive changed. Give the path of a file in your workspace fol…

### `upload_status` (~100 tokens)

Check an upload

Check how an earlier upload was processed, by the uploadId that upload_invoice or upload_invoice_b2c returned. Answers a state of ok, processing or failed, with a downloadId once it is ok. Must be asked of the same environment the upload went to.

Input parameters:

- `id_incarcare` (string, required): The uploadId upload_invoice returned: digits.
- `test` (boolean): TRUE by default. Pass false to file with ANAF for real.

### `validate_invoice` (~221 tokens)

Validate an invoice with ANAF

Check a UBL invoice or credit note against ANAF's own schema and CIUS-RO rules without filing it. Answers valid, and when not, findings: each with the rule it broke (e.g. BR-RO-001), where in the document, and ANAF's text. invoice is what the XML says it is, and file which file was read (name, size, sha256). Needs no grant. CII is not accepted: ANAF validates UBL only. The document goes as xml: { path } for a file, or { content_base64, sha256 } from a script.

Input parameters:

- `xml` (object, required): The invoice XML (at most 5 MB): { path } or { content_base64, sha256 }. Never type or paste a file's base64 yourself: a retyped file can arrive changed. Give the path of a file in your workspace fold…

### `verify_signature` (~429 tokens)

Verify ANAF's seal on an invoice

Check that an invoice is the file ANAF stored, under ANAF's seal (semnatura_*.xml). Give ONE of: message_id (downloads the archive: ANAF allows 10 downloads a day per message), archive (a .zip already in the downloads outbox, from download_invoice; costs nothing), or the two files from an archive kept elsewhere (costs nothing): xml and signature, each { path } or { content_base64, sha256 }, read byte for byte, since the seal covers the invoice's exact bytes. Checked locally first: the certificate against Trans Sped's seal CA and the Ministry of Finance, the signature, and the digest of the invoice's raw bytes. Only when that cannot decide is ANAF asked. Answers valid, checkedBy (local or anaf), a reason when not valid, and the certificate. Revocation is not checked locally.

Input parameters:

- `archive` (string): A .zip in the downloads outbox: its name, or its path under the outbox.
- `message_id` (string): The id field from list_invoices (digits), not requestId.
- `signature` (object): The semnatura_*.xml from the same archive: { path } or { content_base64, sha256 }. Never type or paste a file's base64 yourself: a retyped file can arrive changed. Give the path of a file in your wor…
- `test` (boolean): For message_id only: fetch it from ANAF's test environment.
- `xml` (object): The invoice XML from the archive: { path } or { content_base64, sha256 }. Never type or paste a file's base64 yourself: a retyped file can arrive changed. Give the path of a file in your workspace fo…

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/com-foreverworks-anaf-efactura/foreverworks-mcp-anaf-efactura#diagnostics

## Score history

- 2026-11-05: 83
- 2026-11-04: 83
- 2026-11-03: 82
- 2026-11-02: 82
- 2026-11-01: 81
- 2026-10-31: 66
- 2026-10-30: 80
- 2026-10-29: 80
- 2026-10-28: 80
- 2026-10-27: 79
- 2026-10-26: 79

## Common questions

### What is the ANAF e-Factura MCP server?

ANAF e-Factura is an MCP server listed in the public MCP registry as com.foreverworks/anaf-efactura. Read, check and file a Romanian company's e-invoices and e-Transport declarations with ANAF. This page covers its npm package (@foreverworks/mcp-anaf-efactura).

### Is the ANAF e-Factura MCP server safe to use?

ANAF e-Factura scores 83 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the ANAF e-Factura MCP server expose?

ANAF e-Factura exposes 20 tools: begin_authorization, build_invoice, complete_authorization, download_invoice, etransport_file, and 15 more. Their descriptions and schemas cost roughly 4,440 tokens of context every time the server is loaded.

### Is the ANAF e-Factura MCP server still maintained?

ANAF e-Factura is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the ANAF e-Factura MCP server under?

ANAF e-Factura declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/@foreverworks/mcp-anaf-efactura
- Socket report: https://socket.dev/npm/package/@foreverworks/mcp-anaf-efactura
- Repository: https://github.com/foreverworks/mcps
- Website: https://foreverworks.github.io/mcps/servers/anaf-efactura/
- Changelog RSS feed: https://verifymcp.io/servers/com-foreverworks-anaf-efactura/foreverworks-mcp-anaf-efactura.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-foreverworks-anaf-efactura/foreverworks-mcp-anaf-efactura.json
- HTML version of this page: https://verifymcp.io/servers/com-foreverworks-anaf-efactura/foreverworks-mcp-anaf-efactura