MCP App Store
by KeenEthics
TimberTrail by Kaudata icon

TimberTrail by Kaudata MCP Server for ChatGPT

By KAUDATA d.o.o.

Overview

TimberTrail by Kaudata helps companies that place wood products on the EU market meet the EU Deforestation Regulation (EUDR, Regulation (EU) 2023/1115). It is built for Slovenian sawmills, timber traders, forest-owner cooperatives and the representatives who file for them. This plugin connects ChatGPT to your TimberTrail organisation. ChatGPT acts as you, with your role in TimberTrail, and goes through the same validation, permissions and audit log as the TimberTrail web app. What you can do - Get an overview: what needs attention, amendment deadlines, statements waiting to be filed, unread messages from the competent authority. - Keep master data: suppliers, producers (forest owners), products with their CN codes, Slovenian Forest Service felling decisions (odločba ZGS) and Article 6 mandates (pooblastilo), including attaching the signed mandate or a scan of the decision. - Check whether a CN code falls under the regulation, and work out your organisation's or a supplier's role under it from a short questionnaire. - Check forest plot geolocation from GeoJSON before saving it: coordinate system, geometry errors and area. TimberTrail checks your file as given, and nothing is saved until you ask. - Prepare draft due diligence statements and simplified declarations, from scratch, from a saved template or from a spreadsheet of deliveries, and run TimberTrail's pre-flight checks. - File, amend or withdraw statements in the EU Information System. Every filing act starts with a prepare step that shows exactly what will be sent and to which EU system (the ACCEPTANCE test system or PRODUCTION). The filing tool accepts only the confirmation token from that step, after you say yes. - Refresh statuses and reference numbers, reconcile a submission whose outcome is unknown, review the references you received from suppliers, read the audit trail, and export a statement's evidence pack or a CSV of statements. Who it is for Organisations that hold a TimberTrail account under a contract with KAUDATA d.o.o. and for which Kaudata has switched on AI-assistant access. You sign in with your TimberTrail e-mail and password (and your second factor, if you use one) and approve access on TimberTrail's consent screen. There is no sign-up and nothing to buy in ChatGPT. Limitations - Not available through ChatGPT: entering or replacing EU access keys, managing users and roles, passwords and second factor, and disconnecting AI apps. These stay in the TimberTrail web app. - Your role decides what you can do. Preparers cannot file; auditors can only read. - A clean pre-flight means the rules TimberTrail checks are met, not that the EU Information System will accept the statement. - A filed statement cannot be deleted, only withdrawn, and the EU limits when it can still be amended or withdrawn. - Documents sent through ChatGPT are limited to 11 MB; larger files are uploaded on the TimberTrail screen.

How to connect

  1. ChatGPT: Open the TimberTrail by Kaudata listing in the ChatGPT app directory and choose Connect. ChatGPT listing TimberTrail by Kaudata exposes 80 tools here.

Tools

amend_statement

ChatGPT
Step 2: sends an edited, already filed due diligence statement as an amendment (Art 5(1)). Requires the confirmationToken from prepare_filing action AMEND, which stands for the user's explicit yes. The amendment replaces the whole statement in the EU Information System; the reference number stays and risk profiling restarts. Only inside the 72-hour window. After an unknown outcome (AMENDMENT_OUTCOME_UNKNOWN or OUTCOME_NOT_ESTABLISHED) the statement must not be amended again until the result is recorded from TRACES — resolve_amendment_outcome, or the screen named in the result. Simplified declarations use resend_simplified_declaration.

attach_mandate_document

ChatGPT
Attaches the signed Article 6 mandate (pooblastilo), sent as base64; Art 6(2) requires producing it to the authority on request. PDF, JPEG, PNG or TIFF, at most 11 MB over MCP (the upload screen takes up to 20 MB); the type is checked from the bytes, the same as the upload form. With a document already attached the call is refused unless replace=true, which deletes the old file. A larger file is uploaded on the screen at uploadScreenUrl. The id comes from list_mandates.

attach_zgs_decision_document

ChatGPT
Attaches the scan of a ZGS decision (odločba ZGS) — the Art 9(1)(h) legality evidence — sent as base64. PDF, JPEG, PNG or TIFF, at most 11 MB over MCP (the upload screen takes up to 20 MB); the type is checked from the bytes, the same as the upload form. With a scan already attached the call is refused unless replace=true, which deletes the old file. A larger file is uploaded on the screen at uploadScreenUrl. The id comes from list_zgs_decisions.

check_geometry

ChatGPT
Dry-runs the plot screen's geolocation check on GeoJSON the user supplied (their file, or the GeoJSON behind the QR code on a ZGS decision, odločba ZGS). Saves nothing. Returns every finding with its code and message in the user's language, the detected coordinate system and whether it is ambiguous, areas, and whether each feature can be saved. It checks the text it is given: coordinates constructed, rounded or altered elsewhere bypass the check. Shapefile, KML, GPX and coordinate lists are refused; GeoJSON comes from QGIS (Layer → Save As → GeoJSON) or the ZGS QR code. A Point needs a stated area in hectares; above 4 ha a polygon is required. create_plots saves what it checked.

check_product_scope

ChatGPT
Whether a CN code falls under EUDR by the scope rules in force today, as the products screen shows: IN_SCOPE, OUT_OF_SCOPE, BELOW_ANNEX_LEVEL (fewer digits than the Annex I entry — seats are listed at 8 digits since 18 September 2026, so '9401' decides nothing; requiredDigits says how many digits the full CN code needs) or NOT_DETERMINED. Returns the matched rule with its legal basis and conditions, whether species must be named, and the digits actually sent (annexLevelNote when the entry is longer than the EU accepts). The code is the one in the user's documents. Useful before create_product, or when the question is whether goods are covered. Read-only.

classify_subject

ChatGPT
Records a classification (razvrstitev) of the user's organisation or one supplier: which EUDR role it holds and what it must file. The role is decided by the classification rules in force today from the answers given, each recorded as the user's own. Three questions accept UNKNOWN, itself a recorded answer: an undetermined result is a valid outcome, not a failure. Re-classifying adds a new determination and keeps the earlier ones. The subject comes from list_classifications. Returns the class, the obligations, rationaleSl and uncertaintyNote — the rule's own wording, in the user's language (the field name is historical).

commit_spreadsheet_import

ChatGPT
Creates draft statements (osnutki izjav) from a spreadsheet, exactly as the import screen's commit does: the server re-reads and re-validates the file, imports only the rows that pass under the chosen options, and groups rows by the grouping key — what preview_spreadsheet_import showed for the same file, mapping and options. Optionally sets the mandate (pooblastilo) and EU access the drafts are filed under later, and saves the mapping as a profile. Nothing is filed: each draft still needs run_preflight and a filing of its own.

create_mandate

ChatGPT
Records an Article 6 written mandate (pooblastilo) under which the user files for a principal as authorised representative. Name, identifier, dates and scope come from the signed mandate and are recorded as given; an authorisation not given in writing is not a mandate. A mandate already in list_mandates would be duplicated. Returns the new id, which attach_mandate_document takes for the signed document — Art 6(2) requires producing it to the authority on request — and update_supplier for linking it to a supplier.

create_plots

ChatGPT
Saves plots (parcele) from the user's GeoJSON, exactly as the plot import screen does: the server re-reads and re-validates the same text check_geometry checked. Takes the producer (pridelovalec, from list_producers), optionally the ZGS decision (odločba ZGS), the source coordinate system, and for every Point the area in hectares the user states. A feature whose area would default to 4 ha is never saved. A plot with geometry errors is saved but cannot be filed until corrected. Returns the new plot ids and their validation status.

create_producer

ChatGPT
Adds a producer (pridelovalec): the forest owner or holding where the wood was harvested. The name is filed with the EU exactly as given. A producer already in list_producers would be duplicated. Optionally links the supplier it delivers through (from list_suppliers). Returns the new id, which create_plots and create_zgs_decision take.

create_product

ChatGPT
Adds a product (izdelek): a product group with its CN code, from which statements are built. The CN code comes from the user's customs or sales documents and is recorded as given; check_product_scope answers beforehand whether it is in EUDR scope. Returns the new id and the scope answer, with truncationNote and notes — the screen's warnings.

create_simplified_declaration

ChatGPT
Creates a DRAFT simplified declaration (poenostavljena izjava, Art 4a); nothing is sent to the EU. Takes whether the organisation files for itself (MICRO_OPERATOR) or for a forest owner under a mandate (REPRESENTATIVE_MSPO, with a mandateId from list_mandates); per commodity the HS heading and description; per producer exactly ONE location method — a saved plot, postal addresses, or cadastral identifiers. Pre-flight later blocks filing unless the subject is classified as a micro or small primary operator (classify_subject). Species are recorded, never sent. Filing is run_preflight, then prepare_filing and submit_statement on the user's explicit yes. Returns the new id.

create_statement

ChatGPT
Creates a draft due diligence statement (izjava o potrebni skrbnosti) with the fields of the 'Nova izjava' form: filing in the organisation's own name or for a principal under a mandate (list_mandates), the EU access to file under (list_eu_credentials), the activity, and per goods line the HS heading, description, quantities, species and producer+plot pairs (list_producers, list_plots) — each value the operator's declaration, from the user or their documents. Nothing is sent to the EU; the internal reference is generated and committed now. Simplified declarations are created with create_simplified_declaration. Filing follows run_preflight and prepare_filing.

create_statement_from_template

ChatGPT
Creates a draft statement (osnutek izjave) from a template, as the template screen does: everything is taken from the template except the quantities given per commodity line (net mass in kg, volume in m³, supplementary unit) — this delivery's, as the user states them. Lines not given keep the template's quantities. References that have gone stale are dropped and reported in the result. Nothing is filed; run_preflight checks the draft.

create_supplier

ChatGPT
Adds a supplier (dobavitelj): name, EUDR role, identifier and address, recorded as given — they are the user's business records, and the tool cannot verify them. A supplier already in list_suppliers would be duplicated. A mandate (pooblastilo, from list_mandates) is linked only when the user files on this supplier's behalf. Returns the new id, which classify_subject and create_producer take.

create_zgs_decision

ChatGPT
Records a ZGS felling decision (odločba ZGS o odkazilu drevja za posek), the Art 9(1)(h) proof that the felling was legal. Number, dates, parcels and volume come from the decision itself and are recorded as given; the tool cannot check them against ZGS. A decision already in list_zgs_decisions would be duplicated. Optionally links the producer (from list_producers). Returns the new id, which attach_zgs_decision_document takes for the scan.

delete_import_profile

ChatGPT
Deletes a saved import profile (profil uvoza): a named column mapping for importing a spreadsheet of deliveries as draft due diligence statements. Only the mapping is removed; no statement or other record is affected. The id comes from list_import_profiles.

delete_mandate

ChatGPT
Deletes an Article 6 mandate (pooblastilo) and its signed document; cannot be undone. Meant for a mandate entered by mistake. Refused while any statement was filed under it — those need it as their legal basis, and revoke_mandate is the act for them. The id comes from list_mandates.

delete_plot

ChatGPT
Permanently deletes a plot (parcela), as on the plot screen; cannot be undone. Refused while any statement — draft or already filed — uses it, because deleting would silently remove the geolocation from that statement; the refusal names the statements.

delete_producer

ChatGPT
Deletes a producer (pridelovalec); cannot be undone. Refused while any plot (parcela) belongs to it, because the plots are evidence behind filed statements; the refusal says how many. The id comes from list_producers.

delete_product

ChatGPT
Deletes a product (izdelek); cannot be undone. Statements already built from it keep their own copy of the code and description. update_product with active=false retires a product without deleting it. The id comes from list_products.

delete_supplier

ChatGPT
Deletes a supplier (dobavitelj); cannot be undone. Its producers are kept but lose their link to it. The id comes from list_suppliers.

delete_template

ChatGPT
Deletes a statement template (predloga). Statements already created from it are not affected.

delete_zgs_decision

ChatGPT
Deletes a ZGS decision (odločba ZGS) and its attached scan; cannot be undone. Plots that pointed at it are kept but lose their legality evidence. The id comes from list_zgs_decisions.

execute_grouping

ChatGPT
Groups due diligence statements under Art 8a: creates the grouping statement and files it; the referenced statements are held by it at once and become GROUPED, permanently, when the EU accepts it. Requires the GROUP confirmationToken from preview_grouping for exactly the same statementIds, which stands for the user's explicit yes to the preview and its irreversibility warning. Preconditions are re-checked immediately before filing. After UNKNOWN or OUTCOME_NOT_ESTABLISHED the statements must never be grouped again: the grouping statement is reconciled, or settled on the screen named in the result.

export_statements_csv

ChatGPT
Exports the chosen statements as the CSV the Izjave screen downloads (semicolon-separated, headers in the user's language): references, origin, activity, statuses, mandate principal, commodity totals, species, plots, dates and amendment deadline. Returns the CSV text, its row count and file name; the export is recorded in the audit log. A long export is cut at a row boundary to fit one response and says how many rows it includes; the full file downloads from the Izjave screen. Up to 500 ids.

get_context

ChatGPT
Who the user is (name, role, what the role may do), their organisation (name, operator class and size, when its EUDR obligations apply, whether it was under EUTR), which EU systems its active access keys file into — the system belongs to the key, not the installation; ACCEPTANCE is the test system, PRODUCTION is legally binding — what the installation permits and its label outside production, the readiness checklist (mandate, EU access key, products, plots), record counts, and links to each screen. The organisation's registration and tax numbers, EORI, address and contact come only with include organisationIdentifiers. Useful at the start of a conversation.

get_dashboard

ChatGPT
The Nadzorna plošča overview, as on screen: statements whose amendment window (Art 5(1), 72 hours from the reference number) has under 24 hours left or has just passed, unread messages from the competent authority, counters (this year, available, waiting to be filed, invalid plots, statements in UNKNOWN state), the 10 most recent statements, and the readiness checklist (mandate, EU access, products, plots). The two lists are capped; each gives its total and how many were left out. Useful at the start of a session and for 'what needs attention'. The authority may extend an expired window (Art 5(4)); record_extension_request only records the request. UNKNOWN statements are reconciled, never resubmitted (reconcile_statement). Instants are ISO 8601 UTC.

get_downstream_position

ChatGPT
Shows the organisation's position as a downstream operator or trader (Guidance C/2026/3896 §2(c)), as on the Evidenca prejetih izjav screen. Downstream status — no due diligence statement to file — requires EVERY input to be covered by a supplier's statement or simplified declaration; one uncovered supplier makes the organisation an operator who must file. Returns whether it may rely on downstream status (YES / NO / NOT_ESTABLISHED — NOT_ESTABLISHED is neither yes nor no), whether it must collect references and register in the EU system, per-supplier coverage (gaps first; long lists capped, with counts), retention dates and the screen's findings, in the user's language. Gaps are closed with record_upstream_reference or classify_subject.

get_evidence_pack

ChatGPT
Exports the audit pack (revizijski paket) of one due diligence statement — the JSON the screen downloads from /izjave/<id>/paket, personal data marked withheld (see personalDataWithheld): operator, Art 6 mandate, the EU access used, commodities, producers and plots as filed, ZGS decisions, grouping lineage (which reference number now represents it) and the full lifecycle with stored envelopes. Not for simplified declarations: the pack does not carry their postal addresses or cadastral identifiers. Useful when the user or an authority asks what was filed and on what basis. Every export is recorded in the audit log. A large pack comes back as a summary plus the address to download the full file; the summary does not stand in for the file's content.

get_filing_guide

ChatGPT
Reference documentation for this server: how EUDR filing works and how these tools carry it out. Without a topic it returns the index of topics and "start-here" — the order the work takes and what the filing tools require and refuse. With a topic id it returns that topic — for example "plots-and-geolocation" (coordinates and the 4-hectare rules), "dds-workflow" (preparing and filing), "errors" (every code a tool returns) — or "all" for every topic that fits in one result, naming the rest in notReturned. Static text, the same for every user; writes nothing.

get_mandate

ChatGPT
One Article 6 mandate (pooblastilo) in full: principal, identifier, address and contact, scope, dates, status today, the signed document, how many statements and suppliers use it, and whether it can be revoked or deleted (a mandate used by a statement cannot be deleted, only revoked). documentWarning and identifierWarning are the screen's warnings. The id comes from list_mandates. Read-only.

get_plot

ChatGPT
One plot (parcela) in full: declared and computed area and their difference, area source, source coordinate system, bounding box, producer, ZGS decision, every validation finding, every statement that uses it and whether it reached the EU, and what may be done to it (edit in place, corrected copy, delete). Includes the stored canonical WGS84 GeoJSON and the geometry as originally supplied; either is left out, with a note, when above the size bound.

get_statement

ChatGPT
Everything a careful operator needs about one statement: kind, local and EU status (kept separate — the EU has no concept of our lock reasons), origin, the mandate (pooblastilo) and EU access used, activity, goods lines, producers and plots, reference and verification numbers, the 72-hour correction deadline and how it was derived (Art 5(1): from reference-number availability), any lock and whether an Art 5(4) extension can help, a competent-authority message, when the EU last confirmed and when we last asked, unsent edits, pre-flight, and availableActions — exactly what the screen offers this user now. Read-only. Explanations are the screen's, in the user's language.

get_zgs_decision

ChatGPT
One ZGS decision (odločba ZGS) in full: everything list_zgs_decisions shows plus the QR payload, notes, how many plots point at it, and the attached scan's filename and download link (which opens in the user's browser). The id comes from list_zgs_decisions. Read-only.

import_filed_statement

ChatGPT
Brings a statement filed outside TimberTrail (e.g. directly in TRACES) into the register: by reference number + verification number (retrieves the content), or by internal reference (finds only statements filed under the chosen EU access; returns identifiers and status, no content). Nothing is submitted. The imported statement is marked filed elsewhere (status EXTERNAL) and cannot be amended, withdrawn, grouped or refreshed here. The numbers come from the filer's own records.

list_audit_events

ChatGPT
Reads the organisation's audit log (Revizijska sled), newest first, as on screen: time, event, entity, who acted — a user by display name and role, the system, the EU Information System, or Kaudata staff — the EU fault, and a one-line summary of the recorded detail without personal contact data. Rows written through an AI assistant carry channel MCP and the app's name. Filter by one event type (the result lists the types present); page with limit/offset — the screen shows 50 per page. Stored SOAP envelopes are not returned, only whether one exists; get_evidence_pack carries them for one statement. Append-only: nothing here can be changed. Every role may read it, as on screen.

list_classifications

ChatGPT
The register of actor classifications (razvrstitev subjektov): the user's own organisation and every supplier, each with its current role under Regulation (EU) 2023/1115 — operator, micro/small primary operator, downstream operator or trader — what it must file, the legal basis, the reasoning and any uncertainty note, and the answers it was based on. States are CLASSIFIED, UNDETERMINED (asked, facts did not settle it; not an error) and NEVER_CLASSIFIED. Useful before filing, to see who files at all, and before classify_subject, whose earlier answers it shows. rationaleSl and uncertaintyNote are the rule's own wording, in the user's language (the field name is historical).

list_eu_credentials

ChatGPT
The organisation's access keys to the EU Information System (dostopi do IS EUDR) — never the key itself, and no personal data: a label naming its EU system, whom it files for and when it was added; its EU system (ACCEPTANCE or PRODUCTION), whether this installation may use it and offers it for new statements, status, when it was last used and last passed a connection test. Filing needs an active key; a statement is filed into its key's EU system. Adding, replacing or revoking a key is done only on the screen (url), never here. Read-only.

list_import_profiles

ChatGPT
Lists this organisation's saved import profiles (profili uvoza) — named column mappings for importing a spreadsheet of deliveries as draft due diligence statements: each one's mapping, the header row of the file it was saved from, and when it was last used. A profile's id, given to preview_spreadsheet_import or commit_spreadsheet_import, maps a recurring ERP export without a new mapping.

list_mandates

ChatGPT
The organisation's Article 6 written mandates (pooblastila): whom the user files for, the principal's identifier, what the mandate covers (DDS, simplified declaration or both), validity dates, status today (ACTIVE, REVOKED, EXPIRED, FUTURE) and whether the signed document is attached. A filing needs an ACTIVE mandate; one without its signed document is a gap under Art 6(2). Useful for picking a mandate for a statement or a supplier, and for finding mandates missing their document. Read-only.

list_notifications

ChatGPT
Lists the organisation's notifications, newest first, as on the Obvestila screen. Six kinds: AMENDMENT_WINDOW_WARNING (under 24 hours left to amend), AMENDMENT_WINDOW_EXPIRED, CA_COMMUNICATION (a message from the competent authority), STATUS_REJECTED, STUCK_UNKNOWN (a submission's outcome is unknown — reconciled, never resubmitted), and EU_NOT_RETURNED (the EU no longer returns a filed statement, as for one withdrawn in TRACES; nothing changed here; TRACES shows why). The EU system notifies nobody; the background poll writes these. Filter to unread or one kind; page with limit/offset. Each item names the statement it concerns (get_statement). mark_notifications_read marks them read.

list_plots

ChatGPT
List this organisation's plots (parcele) with the plot screen's fields: producer, ZGS decision, geometry type, area and its source, validation status and findings, and which statements use each plot (a plot already sent to the EU can only be corrected as a copy). No coordinates. Filter by validation status (the screen's filter), producer or name. get_plot returns one plot's full detail and its stored GeoJSON.

list_producers

ChatGPT
The organisation's producers (pridelovalci): the forest owners or holdings where the wood was harvested, with country, the supplier each delivers through, and how many plots (parcele) and ZGS decisions (odločbe ZGS) point at each. Useful for finding a producer's id before adding plots or a ZGS decision, and for seeing whether a producer already exists. Read-only.

list_products

ChatGPT
The organisation's products (izdelki): name, internal code, CN code, the HS code actually sent to the EU (first 6 digits — the EU's business rules refuse longer codes), whether the product is in EUDR scope by the rules in force today (IN_SCOPE, OUT_OF_SCOPE, BELOW_ANNEX_LEVEL when the CN code has fewer digits than its Annex I entry, NOT_DETERMINED), recycled share, packaging flag and whether it is active. Useful for picking a product for a statement and for seeing whether one already exists. truncationNote, annexLevelNote, message and notes are the screen's warnings. Read-only.

list_simplified_declarations

ChatGPT
Lists the organisation's simplified declarations (poenostavljena izjava, Art 4a) — the one-time filing of a micro or small primary operator, made for the organisation itself (MICRO_OPERATOR) or for a forest owner under an Art 6 mandate (REPRESENTATIVE_MSPO). Same register as the Poenostavljene izjave screen: internal reference, the subject it is for, role, location method, local and EU status, EU identifier. Filter by local status; page with limit/offset. Due diligence statements are a separate register (list_statements). get_statement returns one declaration's content; filing one is run_preflight, then prepare_filing and submit_statement on the user's explicit yes.

list_statements

ChatGPT
List this organisation's statements — due diligence statements (izjava o potrebni skrbnosti, DDS) and simplified declarations (poenostavljena izjava, Art 4a) — newest first. Filter by kind, local status, origin or part of a reference; bounded by limit and offset. Each row gives the local status and the EU status separately, the origin (filed here, filed elsewhere, demonstration data — never sent), the correction deadline and what needs attention. get_statement returns one statement's full detail and the actions available on it.

list_suppliers

ChatGPT
The organisation's suppliers (dobavitelji): name, EUDR role, identifier, address, the Article 6 mandate (pooblastilo) linked to each, and how many producers point at it; contact e-mail and phone only with includeContact. Useful for finding a supplier's id before updating, classifying or linking it, and for seeing whether a supplier already exists before one is created. Read-only.

list_templates

ChatGPT
Lists this organisation's statement templates (predloge izjav): activity, mandate and EU access, how many commodity lines each has, and any reference that has gone stale since (a revoked mandate, a deleted plot) and would be dropped. With an id, one template with every commodity line — description, CN code, species, producers and plots, default quantities. create_statement_from_template builds a draft from one with new quantities.

list_zgs_decisions

ChatGPT
The organisation's ZGS felling decisions (odločbe ZGS o odkazilu), the Art 9(1)(h) legality evidence: number, dates, issuing unit, forest owner, producer, cadastral municipality, parcels, volume and whether the scan is attached. Newest first. Useful for finding a decision's id, for seeing whether one already exists, and for finding decisions still missing their scan (missingDocument=true). Read-only.

mark_notifications_read

ChatGPT
Marks notifications as read for the whole organisation, as the Obvestila screen does — either the given ids, or every unread one with all=true — so they leave every colleague's unread list as well. Changes no statement and no filing; any role may do it. Returns the screen's confirmation, in the user's language, and how many remain unread.

prepare_filing

ChatGPT
Step 1 of every filing act. action: SUBMIT (first filing of one statement), AMEND (send an edited DDS as an amendment — replaces the whole content), WITHDRAW (final), SD_UPDATE (re-send a simplified declaration's stored content), BULK_SUBMIT (up to 3 due diligence statements; more go in several confirmed batches). Checks the live role and status, runs pre-flight where the screen does, and returns exactly what will be sent and to which EU system, with warnings. Only when it can proceed does it return a confirmationToken — valid 15 minutes, single use, void if the statement changes. The token stands for the user's explicit yes to that summary and its warnings; the filing tool named in the result accepts nothing else.

preview_grouping

ChatGPT
The mandatory preview before grouping due diligence statements under Art 8a into one grouping statement (skupinska izjava). Shows what it would carry, why any selected statement is excluded, and the warnings. Grouping is irreversible: every referenced statement becomes GROUPED and can never again be amended or withdrawn. On 5 August 2026 EU ACCEPTANCE refused a real grouping submission with EUDR-REFERENCED-STATEMENT-NOT-YET-IMPLEMENTED. When grouping can proceed and the user may file, returns a GROUP confirmationToken for execute_grouping.

preview_spreadsheet_import

ChatGPT
Reads a spreadsheet of deliveries (CSV as text, XLSX/XLS as base64), maps its columns and validates every row, as the import screen (/uvoz) does — saving nothing. Returns the headers, the mapping used (a saved profile, the automatic suggestion, or the columns given), each row's outcome and issues in the user's language, and what a commit would create: draft statements (izjave), and producers or ZGS decision numbers only on the user's opt-in. Plots must already exist. A wrong column mapping produces wrong drafts without any error. commit_spreadsheet_import takes the same file, mapping and options.

reconcile_statement

ChatGPT
Resolves a statement in status UNKNOWN (an ambiguous submission) by asking the EU, by our internal reference, whether it exists. If found, the EU's status is applied. If not, the statement returns to READY and may be filed again — only through prepare_filing and the user's explicit yes. Refused until 30 minutes after the statement's last send (reconcileNotBefore in the result), as for the background job: an earlier 'not found' is not evidence the filing failed. An UNKNOWN statement is reconciled, never submitted again.

record_extension_request

ChatGPT
Records a reasoned request for an Art 5(4) extension of a due diligence statement's correction window — up to 8 calendar days, grantable retroactively, and only for clock expiry, never for an Art 5(3) lock. It records the request and the user's reasoning in TimberTrail and its audit log ONLY, and sends nothing to the competent authority: the request to the authority is the user's own to make, and only the authority can grant it.

record_upstream_reference

ChatGPT
Records one reference a supplier gave for an incoming consignment (Evidenca prejetih izjav). identifierKind: DDS_REFERENCE_NUMBER (14-character reference, with its verification number when the supplier gave one), SD_DECLARATION_IDENTIFIER (UUID of a simplified declaration), CONVENTIONAL_TRANSITIONAL (the literal 99EU9999999999 — a valid record that never counts as covered), CONTINGENCY (an Art 15a outage reference). Takes the supplier, product, consignment reference, receipt date, quantity and whether the organisation is the first downstream operator for it, from the user's records. References are NOT checked against the EU system — that verification is not built — so a recorded number proves only that it was collected. get_downstream_position shows the effect.

refresh_statement_status

ChatGPT
Ask the EU Information System for a statement's current status (getDds, or getSd for a simplified declaration) and apply it: reference and verification numbers, EU status, competent-authority messages. Never submits anything and never decides anything on the EU's silence. The Commission asks integrators to wait at least 30 minutes after a submission before asking; earlier answers usually repeat the same state. Returns what changed and, when a reference number first appears, the 72-hour correction deadline it starts (Art 5(1)).

refresh_statements

ChatGPT
Asks the EU Information System for the current status of several filed statements (Osveži on the Izjave list) and stores what it says. Reads only — never submits, amends or resubmits. Per statement: OK (confirmed or changed), SKIPPED with the reason (not filed yet, a simplified declaration, a demonstration record, filed elsewhere, no EU identifier, under 30 minutes since submission as the EU asks, or not returned by the EU, as for one withdrawn in TRACES; nothing changed), or FAILED with the EU fault. Each item names its EU system (ACCEPTANCE or PRODUCTION) — that of the statement's own access key. refresh_statement_status covers a single statement or a simplified declaration. Up to 100 ids per call.

remove_mandate_document

ChatGPT
Detaches and deletes the signed document of an Article 6 mandate (pooblastilo), keeping the mandate; the file cannot be recovered. Afterwards the mandate cannot be produced to the authority as Art 6(2) requires until a new document is attached. The id comes from list_mandates.

remove_zgs_decision_document

ChatGPT
Detaches and deletes the scan of a ZGS decision (odločba ZGS), keeping the decision record; the file cannot be recovered. Afterwards the decision is a claim rather than evidence under Art 9(1)(h). The id comes from list_zgs_decisions.

resend_simplified_declaration

ChatGPT
Step 2: updates a filed simplified declaration (poenostavljena izjava, Art 4a(3)) by re-sending its stored content whole (updateSd). Requires the confirmationToken from prepare_filing action SD_UPDATE, which stands for the user's explicit yes. It replaces what the EU holds and restarts risk profiling; simplified declarations have no 72-hour window. After OUTCOME_NOT_ESTABLISHED it must not be resent; refresh_statement_status and the screen named in the result settle it.

resolve_amendment_outcome

ChatGPT
Records what the user established about an amendment whose outcome is unknown: LANDED (the EU holds the amended content) or NOT_LANDED (it still holds the previous content). TimberTrail cannot determine this; only a check of the statement in TRACES can. 'evidence' is required — where and when the user checked and what they saw — and is written to the append-only audit log as the user's assertion.

revalidate_plot

ChatGPT
Re-runs today's geolocation checks on a saved plot's stored geometry and stores the new status and findings, as the plot screen's »Znova preveri« does. Useful when a plot was checked under older rules, or before filing a statement that carries it. A plot already sent to the EU keeps the evidence frozen on its filed statements; the result says so. Returns the new status and findings.

revoke_mandate

ChatGPT
Revokes an Article 6 mandate (pooblastilo) as of today. The record stays readable — it is the legal basis of statements already filed under it — but no new statement may be filed under it. This, not delete_mandate, is the act for a principal withdrawing the mandate. The id comes from list_mandates.

run_preflight

ChatGPT
Run the local pre-flight checks (predhodno preverjanje) for one statement — the same rules the screen shows and the filing step enforces, each kind against its own rulebook. Read-only; nothing is sent to the EU. Returns every finding with its level (BLOCKING stops a filing; WARNING does not, and is the screen's warning to the user), its code and the message as the application wrote it, in the user's language, plus where on screen it is fixed. A statement with any blocking finding cannot be prepared for filing.

save_import_profile

ChatGPT
Saves a named import profile (profil uvoza) for importing a spreadsheet of deliveries as draft due diligence statements, as the import screen does: which column of the user's file holds which field (CN code, description, net mass and so on). Later, preview_spreadsheet_import and commit_spreadsheet_import take the profile's id instead of a new mapping. Takes a profile name, the file (as preview_spreadsheet_import reads it) and the columns to map; fields not given keep the automatic suggestion. The profile also keeps the file's header row, so a later export with different columns is noticed. Saving under an existing name replaces that profile. Creates no statements and imports no rows. Returns the profile id and its mapping.

save_statement_as_template

ChatGPT
Saves a statement (izjava) as a reusable template (predloga), as the statement screen's »Shrani kot predlogo« does: activity, mandate, EU access and every commodity line with its species, producers, plots and quantities as defaults. Useful when the same statement is filed regularly. Names are unique in the organisation. Returns the template id.

submit_statement

ChatGPT
Step 2: files one statement — a DDS or a simplified declaration — into the EU Information System. Requires the confirmationToken from prepare_filing action SUBMIT, which stands for the user's explicit yes. A legal act: a filed statement cannot be deleted, only withdrawn. Outcomes: SUBMITTED (the reference number follows; refresh_statement_status after 30 minutes), REJECTED or FAILED (refused by the EU), BLOCKED_BY_PREFLIGHT (nothing sent), UNKNOWN (reconcile_statement settles it), OUTCOME_NOT_ESTABLISHED (may be at the EU; settled on the screen). A statement in UNKNOWN or OUTCOME_NOT_ESTABLISHED must never be submitted again: a duplicate can only be withdrawn. Every result names the EU system.

submit_statements

ChatGPT
Step 2 of a bulk filing: submits several due diligence statements with the confirmationToken from prepare_filing action BULK_SUBMIT — the same statementIds, unchanged — which stands for the user's explicit yes. Only the statements prepare_filing said would proceed are filed; those it announced as skipped stay skipped. Returns a per-statement outcome — SUBMITTED, SKIPPED, REJECTED, FAILED, UNKNOWN or OUTCOME_NOT_ESTABLISHED — with its status now and the EU system. A statement now UNKNOWN or OUTCOME_NOT_ESTABLISHED must never be submitted again: reconcile_statement for UNKNOWN, the screen named in the result otherwise. At most 3 statements per call, since each EU call may take a minute; a larger set is filed in several batches, each prepared and confirmed.

test_eu_credential

ChatGPT
Tests one EU access key against the EU Information System's echo service, as the 'Preizkus povezave' button does: proves the username, key and signature are accepted, and files nothing. Only an OWNER may run it. The echo service exists only on the ACCEPTANCE system, so a PRODUCTION key cannot be tested this way and the result says so. On failure it returns the screen's message and nextSteps, in the user's language; the fix (a new key) is made on the screen, never here. The id comes from list_eu_credentials.

update_mandate

ChatGPT
Changes an Article 6 mandate (pooblastilo). Takes the id (from list_mandates) and only the fields that change: omitted fields keep their value, null clears an optional one. Values come from the signed mandate and are recorded as given. The signed document is never touched here (attach_mandate_document, remove_mandate_document); revoking as of today is revoke_mandate.

update_plot

ChatGPT
Corrects a saved plot: name, producer, ZGS decision, declared area, or its geometry from the user's new GeoJSON (check_geometry checks it beforehand; its coordinate system is required). The screen's rule applies: a plot already sent to the EU in a statement is never changed — the correction is saved as a NEW plot (corrected copy) and the original stays as declared. The result says which happened and returns the plot id to use from now on. A copy needs a different name (default '<name> (popravek)'). Omitted fields stay as they are. Every save is re-validated; a Point without an area is refused.

update_producer

ChatGPT
Changes a producer (pridelovalec). Takes the id (from list_producers) and only the fields that change: omitted fields keep their value, null clears an optional one. The name is filed with the EU as written. A supplierId comes from list_suppliers.

update_product

ChatGPT
Changes a product (izdelek). Takes the id (from list_products) and only the fields that change: omitted fields keep their value, null clears an optional one. Statements already filed keep their own copy and are not changed. check_product_scope answers whether a new CN code is in scope.

update_statement

ChatGPT
Changes a due diligence statement's content, as the 'Uredi' form does. Omitted fields keep their current values; 'commodities', if given, replaces all goods lines. Allowed for a draft, a statement rejected at submission, or a filed DDS whose 72-hour window is open. On a filed statement the edit is saved here only: the EU keeps the previous content until the edit is sent with amend_statement (after prepare_filing AMEND) before the deadline. The mandate and EU access of a filed statement cannot change. Simplified declarations cannot be edited.

update_supplier

ChatGPT
Changes a supplier (dobavitelj). Takes the id (from list_suppliers) and only the fields that change: omitted fields keep their value, null clears an optional one. Identifiers and addresses are recorded as given. A mandateId comes from list_mandates.

update_zgs_decision

ChatGPT
Changes a ZGS decision (odločba ZGS). Takes the id (from list_zgs_decisions) and only the fields that change: omitted fields keep their value, null clears an optional one; parcelRefs replaces the whole list. Values come from the decision itself and are recorded as given. The attached scan is never touched here — attach_zgs_decision_document and remove_zgs_decision_document handle it.

validate_statements

ChatGPT
Runs pre-flight on several statements at once (Preveri on the Izjave list), each against its own rulebook — a simplified declaration is checked as one. Changes nothing and sends nothing; the run is recorded in the audit log. Returns per statement OK or FAILED with the errors and warnings in the user's language, and the ids that are not statements of this organisation. A statement with a blocking error cannot be prepared for filing. Up to 100 ids per call.

withdraw_statement

ChatGPT
Step 2: withdraws a filed statement — a DDS or a simplified declaration — from the EU Information System. Requires its own confirmationToken from prepare_filing action WITHDRAW (a SUBMIT or AMEND token is refused), which stands for the user's explicit yes. Withdrawal is final: a withdrawn statement cannot be reactivated. A DDS can be withdrawn only while its 72-hour window is open and it is neither locked under Art 5(3) nor grouped. After OUTCOME_NOT_ESTABLISHED a withdrawal must not be repeated; refresh_statement_status shows whether it landed.

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/timbertrail-by-kaudata"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/timbertrail-by-kaudata)