Application lifecycle

An application has two independent sides:

• the application state, owned by Finto: whether the application is open for you, whether the client chose your offer, whether it ended;
• your decision status, owned by you: what you did with it, from review to payout.

Both are in every application response (state and decision.status).

Application state (Finto)

State	Meaning	You may send
open	The application is active. Review it and decide	Any decision allowed by the table below
offer_selected	The client chose your offer. Continue with the agreement	Any decision allowed by the table below
closed	It ended for you; closedReason says why	Only contract_signed, disbursed, cancelled, terminated
withdrawn	The client withdrew consent	Nothing. The data is no longer available (410)

The state is yours alone: when the client chooses lender A, lender B's application stays open until the outcome is known (see scenario 6).

Why an application closes

closedReason	When
completed	Your outcome is final: you reported disbursed, or cancelled after an agreement. Later changes to the agreement are still accepted (scenario 12)
other_offer_chosen	The client signed with another lender, or turned from your chosen offer to another
client_declined	The client no longer wants the financing
expired	Nothing ended the application by expiresAt
duplicate	A newer application of the same client replaced this one (replacedBy, when it was also sent to you)
closed_by_finto	Finto closed it for another reason

expiresAt

30 days after the client signed, as long as the application is open for you. Once the client chooses your offer, 90 days after signing, to leave room for the agreement and the payout. At expiresAt Finto closes the application for you as expired.

Your decision status

The diagram shows the usual paths. The exact rule is this table:

Current status	You may send next
none yet, in_review, info_required, approved	anything except terminated
contract_signed	contract_signed (correction), disbursed, cancelled
disbursed	disbursed (correction), cancelled (withdrawal only), terminated
terminated	terminated (correction), cancelled (it was a withdrawal), disbursed (it did not end after all)
rejected	rejected (correction), contract_signed, disbursed. Anything except terminated, when your applicationVersion is newer than the one the rejection was based on
cancelled	contract_signed, disbursed

Anything else returns 409 invalid_transition. Notes:

• Before an agreement, anything goes. You do not have to send in_review or approved first: if the client signed with you directly, send contract_signed; if you signed and paid out the same day, disbursed alone is fine (with contract details in the same request). An agreement or a payout is accepted even after rejected or cancelled: the client may have come back to you.
• The same status again replaces the details: a new offer, updated requirements, a corrected contract number. Not for cancelled: it is final.
• Your offer can be chosen only while your current status is approved.in_review or info_required after approved put the offer on hold until you send approved again; rejected withdraws it.
• rejected is final for the version it was based on. When the client provides documents or data changes, the application gets a new version (application.updated), and a decision based on that version (applicationVersion) may follow your rejection.
• After the payout the agreement can still change: the client withdraws within the statutory period (cancelled with withdrawal_right; no other reason is accepted after disbursed), or it ends early (terminated). See scenario 12.
• After closed only facts about the outcome are accepted (contract_signed, disbursed, cancelled, terminated); anything else returns 409 application_closed. This covers the race where you send an offer just as the application closes: treat that error as "stop, it is closed".
• After withdrawn nothing is accepted (410 application_withdrawn).

Versions, order and conflicts

• Every decision carries the applicationVersion it is based on. A decision made on version 1 while version 2 already exists is accepted and shown to Finto staff with that version, so nobody mistakes an offer on old data for one on new data.
• Finto applies your decisions in the order it receives them, one at a time per application; decidedAt is only shown. If several of your processes may decide on the same application, send previousDecisionId (the decision.id you last saw): when another decision got in first, the request fails with 409 decision_conflict and you decide again on fresh data.

After the client chooses your offer

You get offer.selected, your state is offer_selected, and selection names the decision the client chose. This is the moment to contact the client, or to wait for them at your continueUrl, and to sign the agreement.

You send	Effect
info_required, in_review	The choice stands. Ask for what you need before signing
approved with the same terms	The choice stands. You may extend validUntil or replace the documents (for example an updated SECCI form)
approved with different terms	The choice ends, your state returns to open, and the client chooses again with your new offer. Terms are everything except validUntil and documentIds
rejected	Your offer is withdrawn; the choice ends and the client can choose another offer
cancelled	The choice ends (the client did not go ahead)
contract_signed	The other lenders' applications close (other_offer_chosen)
disbursed	Your application closes as completed

If the client turns to another offer after choosing yours, you get application.closed (other_offer_chosen) right away, so that you stop preparing the agreement.

What each status does on Finto's side

You send	Finto staff see	The client sees (self-service, coming later)
in_review	"Reviewing", your reference number	"Being reviewed"
info_required	Your requirements, an alert to collect them	What to provide, with your descriptions
approved	Your offer: amount, term, payment, rates, validity, conditions	Your offer next to others, with your documents
rejected	Rejected, with your reason	"No offer" (never the reason)
contract_signed	Signed with you	Signed
disbursed	Paid out	Paid out
cancelled	Ended without financing, with the reason	Ended
terminated	Paid out, ended early, with the date and reason	Ended early

Texts that reach the client (requirements[].description, offer.conditions) must be in plain Lithuanian and without links. message and rejectionReason are for Finto staff only.

Time limits

What	Limit
Open application	Closes as expired 30 days after signing, if no offer was chosen
Application with your offer chosen	Closes as expired 90 days after signing, if no outcome was reported
Offer	Valid until offer.validUntil (inclusive, Vilnius time), at most 180 days ahead. An expired offer cannot be chosen; send approved again to extend it
Reading the application	While you work on it, and 14 days after your first final decision (rejected, cancelled, disbursed, terminated) or after it closes for you; a newer version opens it again. Then 410 application_archived. Corrections and later reports do not extend it
Reporting on the agreement	No limit: cancelled (withdrawal), terminated and corrections are accepted, and your decisions stay readable (GET .../decisions), also after reading has ended
Events feed	Events kept for 30 days

Response times

Clients are waiting on the other end. We recommend:

• in_review within minutes of application.submitted (automatic for most lenders);
• a decision (approved, rejected or info_required) within one business day, the same day where you can;
• the outcome (contract_signed, disbursed, cancelled) on the day it happens;
• later changes to the agreement (a withdrawal, terminated) within two business days.

Scenarios

Every scenario below can be played in the sandbox with POST /v1/sandbox/applications/{applicationId}/simulate (see sandbox.md).

1. Offer, agreement, payout

2. Rejection

application.submitted → fetch → rejected, with a rejectionReason if you share reasons. Nothing else is needed from you. You still get application.closed when the application ends, so you can archive it.

3. Documents requested

Ask for everything you need in one info_required. If more is needed after the documents arrive, send info_required again with the new list.

4. A different amount or term, or an updated offer

You may offer less (or more) than requested, or another term: send approved with your amount and term. To change the offer later, send approved again; it replaces the previous one. If the client had already chosen it, see the table above.

5. Withdrawing an offer

New information from your checks, or the offer can no longer be honoured: send rejected. If the client had already chosen it, the choice ends and Finto helps the client choose another offer.

6. The client chooses another lender

Your application stays open while the chosen lender completes the agreement: the client may still come back to your offer. When an agreement with another lender is confirmed, you get application.closed with other_offer_chosen. You are not told which lender was chosen. Closing is final: if that agreement later falls through, the client applies again.

7. The client declines, or the application expires

application.closed with client_declined or expired. Stop the review.

8. The client withdraws consent

The client may withdraw the consents of the signed application (passing the application on, contact and reporting to Finto) by writing to Finto or to you.

• Through Finto: you get application.withdrawn. Stop processing the client's data for this application: assessing it, making offers and reporting to Finto. Finto no longer serves the application or its documents (410), and no decisions are accepted. If you already signed an agreement with the client, the agreement and the processing it requires are not affected; you simply stop reporting to Finto.
• Directly with you: send cancelled with consent_withdrawn as your last decision. Finto then stops sending you anything about this application and asks the client whether the withdrawal covers the other lenders too.

9. Data corrected after signing

The client asks Finto to correct a plain error in contact data (for example a mistyped phone number). Finto creates a new version with a versionNote and sends application.updated with changes: ["data"]. The signed PDF stays as signed. Anything more than that needs a new signature (see signed-application.md). If the change affects your decision, send a new one based on the new version.

10. The client signed with you directly

If the client signs with you without choosing your offer through Finto, report contract_signed all the same, from whatever status you are in. Finto staff confirm it with the client, and then the other lenders' applications close. Until then your state stays as it was.

11. The client changes their mind after choosing you

If the client turns to another offer, or no longer wants the financing, after choosing yours, you get application.closed (other_offer_chosen or client_declined) right away. The other lenders, who never started an agreement, stay open as in scenario 6.

12. After the payout: withdrawal or early end

An agreement that was paid out may still change. Report it, also long after the payout:

• The client withdraws within the statutory period: send cancelled with withdrawal_right, even after disbursed. For Finto the financing did not happen.
• The agreement ends before its term: send terminated with termination.endedOn and termination.reason: early_repayment (repaid ahead of schedule, for example after refinancing elsewhere, or the car bought out early), terminated_by_client (for example the leased car returned), terminated_by_lender or other (explain in message). Do not send why you terminated it or any amounts: Finto does not need them.
• A mistake is corrected the same way: terminated again with the right date or reason, cancelled if it was in fact a withdrawal, disbursed again if the agreement did not end.

Reading the application still ends 14 days after the payout; these reports are accepted all the same and do not open it again. Your own decisions stay readable with GET /v1/applications/{applicationId}/decisions, so you can check your latest one before you report.

13. You need the spouse as co-borrower

Send info_required with spouse_data. Finto collects the spouse's name, personal code and email, adds them to spouse and sends application.updated (data). The spouse's consent to your checks is then yours to collect, with your consent form (scenario 14) or at signing.

14. You need your own consent form signed

Upload the form as consent_form (POST .../documents), then send info_required with lender_consent. Finto gets it signed by the client and attaches the signed copy (consent_form, uploadedBy: client) with application.updated (documents).

15. A webhook did not arrive

Your endpoint was down. Finto retries for about two days; meanwhile your feed poller picks the event up from GET /v1/events. Both paths deliver the same id, so the event is processed once.

16. A request timed out

You sent a decision and the connection dropped before the answer. Send the same request again with the same Idempotency-Key: if the first one was stored, you get it back with 200; if not, it is stored now (201).