Skip to content

Automate certification

Certifying a document means bringing it into the module, then submitting it to the FNE. By hand, someone fills in an Excel workbook, uploads it and clicks Transmettre (Transmit). Automated, the same chain starts from your management system and returns to it without anyone opening the module: your invoices and credit notes are collected, submitted to the FNE, and their result is handed back to you.

This page presents the principle of the methods the module offers to achieve this.

Overview

The module offers three methods. The first two rest on the same foundation, the collect of the model: an SFTP drop, declared on a model, where documents arrive as files and from which results leave. With the third, the API, your system talks to the module directly, with no file drop.

flowchart LR
    SI["Your management<br/>system"]
    PROG["Your export<br/>program"]
    AGENT["Resident agent"]
    SFTP[("SFTP drop<br/>of the collect")]
    MOD["Fiscal invoicing<br/>module"]
    FNE["FNE (DGI)"]
    SI --> PROG
    SI --> AGENT
    PROG <-- "documents and results" --> SFTP
    AGENT <-- "documents and results" --> SFTP
    SFTP <-- "collection and return" --> MOD
    MOD <-- "certification" --> FNE
    SI <-- "API" --> MOD
  • Your own collection: your system exports its documents to the drop itself and retrieves the results there.
  • The resident agent: a program supplied by Minlessika, installed on your premises, reads your documents in your database and does this work for you.
  • The API: your system sends each document straight to the module, which notifies it of the result or gives it on request.

The common principles

Whatever the method, the chain obeys the same rules:

  • Submission is automatic. A received document is imported, then submitted to the FNE without any intervention.
  • The result returns to its source. Once the verdict of the FNE is known, the module hands the answer back — FNE reference and certified PDF, or reason for rejection — the way the document came in.
  • Everything stays visible. Received documents appear in Imports and in the Historique des transmissions (Transmission history), like the ones you upload by hand, and a failed document is replayed from Factures et avoirs en échec (Failed invoices and credit notes).
  • The invoice first, the credit note next. A credit note cites the invoice it corrects: the FNE only certifies it once that invoice is certified.

The two file-based methods also share the rules of the collect of the model:

  • One file, one document. Each invoice and each credit note travels in its own file, which the module recognizes by the model marker it carries.
  • The module comes and fetches. It checks the drop at regular intervals; nothing has to be pushed to it.

Method 1 — Your own collection

Your management system, or a program you write beside it, produces one file per document and drops it on the SFTP drop. It then retrieves what the FNE answered. The module supplies the empty file to fill in; the rest of the exchange is a file contract, which you implement at your own pace and with your own tools.

sequenceDiagram
    autonumber
    participant P as Your program
    participant S as SFTP drop
    participant M as Fiscal invoicing
    participant F as FNE
    P->>S: drops one file per document
    M->>S: collects the files
    M->>F: submits each document
    F-->>M: FNE reference or rejection
    M->>S: drops the verdict and the certified PDF
    P->>S: retrieves the results

This method suits a system able to export files and speak SFTP. The contract is detailed in Integrate your own invoice collection.

Method 2 — The resident agent

The resident agent is a program supplied by Minlessika, installed on a machine of your network. It reads the invoices and credit notes in your database itself, drops them on the drop of the collect, then brings the results back into your database. You write no program: you expose your documents in views, and the mapping between these views and the model is set from the module.

sequenceDiagram
    autonumber
    participant B as Your database
    participant A as Resident agent
    participant S as SFTP drop
    participant M as Fiscal invoicing
    participant F as FNE
    M-->>A: configuration: views to read, field mapping
    A->>B: reads the new or modified documents
    A->>S: drops one file per document
    M->>S: collects the files
    M->>F: submits each document
    F-->>M: FNE reference or rejection
    M->>S: drops the verdict and the certified PDF
    A->>S: retrieves the results
    A->>B: writes the results into a return table

Three principles govern the agent:

  • It is driven from the module. The agent enrolls once, in Paramètres › Agents résidents (Settings › Resident agents), then fetches its configuration by itself. Changing a field mapping requires no intervention on its machine.
  • It only reads what moved. At each pass, it only takes the documents created or modified since the previous one.
  • Your access data stays with you. The access to your database never leaves the machine of the agent, which reads your views read-only and only opens outbound connections.

This method suits those who do not wish to develop anything.

Getting the agent

The agent reads Oracle databases today. Ask your Minlessika contact for it: its installation manual comes with it.

Method 3 — The API

Your management system talks to the module directly, through secure web calls: it sends each invoice and each credit note. There is no file drop to keep and no program to install on your premises.

Certification is not instantaneous: the module acknowledges the document, then submits it to the FNE. The result then reaches you in one of these two ways:

  • By webhook. You declare an address of your system, and the module calls it as soon as the verdict of the FNE is known. Your system has nothing to ask: it is notified.
  • By status check. Your system asks the module, at the pace that suits it, for the status of an invoice or a credit note. This way serves the systems that expose no address reachable from the Internet: every call starts from your side.
sequenceDiagram
    autonumber
    participant P as Your system
    participant M as Fiscal invoicing
    participant F as FNE
    P->>M: sends a document
    M-->>P: acknowledges receipt
    M->>F: submits the document
    F-->>M: FNE reference or rejection
    alt By webhook
        M->>P: calls your address with the verdict
    else By status check
        P->>M: asks for the status of the document
        M-->>P: hands back the verdict
    end

This method suits a system able to call a web service, and those who want the result as close as possible to the issuing of the document.

Choosing your method

Three questions are enough to find your way:

flowchart TD
    Q1{"Can you make your<br/>management system evolve?"}
    Q2{"Can it call<br/>a web service?"}
    Q3{"Are your documents<br/>in an Oracle database?"}
    API["Method 3<br/>The API"]
    COL["Method 1<br/>Your own collection"]
    AGT["Method 2<br/>The resident agent"]
    XLS["Excel import"]
    Q1 -- "Yes" --> Q2
    Q1 -- "No" --> Q3
    Q2 -- "Yes" --> API
    Q2 -- "No, but it exports files" --> COL
    Q3 -- "Yes" --> AGT
    Q3 -- "No" --> XLS

The following table sums up what sets the methods apart:

Excel import Your own collection Resident agent API
Who brings the documents Someone uploads a workbook Your program drops files The agent reads your database Your system calls the module
What you develop Nothing The file export and the reading of results Nothing: you expose views The API calls
Submission to the FNE A click on Transmettre (Transmit) Automatic Automatic Automatic
Where the result returns On screen On the SFTP drop In your database By webhook, or on request from your system

The Excel import is not an automation: it appears here as a point of comparison, and remains useful for small volumes or a one-off catch-up.

What next?

Changelog

  • 1.0 (October 1, 2026): document created.