Fiorino.AI

A one-sentence summary

Fiorino.AI is an open-source tool for managing the costs and usage of LLMs; it assists AI SaaS teams in tracking Tokens by user, model, and business criteria, estimating costs, setting pricing adjustments, and providing the data needed for billing based on usage.

Tool Introduction

Fiorino.AI is intended for development teams that wish to incorporate OpenAI, Anthropic, or other large-model services into their products. It receives information such as external user identifiers, input/output tokens, providers, and models via REST APIs, and then aggregates this data in cost dashboards.

The project is maintained by a GitHub organization with the same name; the backend is built using Python, FastAPI, SQLAlchemy, and PostgreSQL, while the frontend utilizes React, TypeScript, Vite, and Recharts. Users can deploy the backend via Docker or build their own standalone frontend.

The authorities have identified usage limits, Stripe-based billing, business tagging, and AI cost analysis as key areas for development, but many of the items on this roadmap are still not yet implemented. Since the last public update to the warehouse was in July 2025, it is necessary to rely on the actual code and local tests before adopting it officially.

Main functions

Record LLM invocation usage

The application can receive anonymous external user IDs via tracking interfaces, as well as input and output Tokens, along with the provider and model names. Once a model has been called, the team must send the exact usage data to Fiorino.AI.

Analyze costs by user

The system uses anonymous external IDs to identify users, allowing for the tracking of each user’s usage of LLMs and the associated costs. Anonymous IDs help reduce the amount of direct identity data available, but if the mapping tables are still stored in the business system, it is still possible to re-associate that data with individual people.

Multiple models and multiple providers

The goal of this project is to provide unified tracking of different large-model services and model versions, thereby avoiding the need for each provider to keep its own records. The price list must be updated regularly; otherwise, even if the number of tokens is correct, incorrect costs may still be incurred.

Cost Dashboard

The frontend provides visualizations such as real-time cost trends, Token usage, and model distribution. The dashboard helps identify users with high costs and abnormal fluctuations, but it does not represent the final bill from the cloud service provider.

Model cost and markup

The backend can manage model costs and set custom surcharges, which are used to estimate the gross profit of the service or to determine customer prices. The pricing calculation should take into account inputs, outputs, caching, batch processing, and other billing factors specific to different providers.

Realm multi-tenant boundaries

The official documentation organizes different applications or tenants using Realm, and generates an API Key for each integration. In a multi-tenant deployment, it is necessary to ensure isolation of queries, keys, and data among different Realms; reliance solely on the user interface is not sufficient.

API Key management

The frontend README lists the developer tools for creating and managing API keys. In a production environment, the full key should be displayed only once; it should be stored as a hash, and features such as revocation, rotation, and least-privilege access should be available.

Usage limits and reminders

The official website and the main README list setting quotas based on the user or subscription plan, as well as providing alerts when approaching the limit, as available features. The old roadmap still marks quotas, rate limits, and reset periods as planned items; therefore, it is necessary to verify each of these elements in the current code.

Stripe usage-based billing

Project promotion can be combined with Stripe for usage-based billing, but the old roadmap still lists modular billing as a planned option. One cannot assume that complete billing, refund, tax, and reconciliation processes are already available for use in production based solely on the README file.

AI Cost Analyst and custom insights

The official description includes information on the costs associated with natural language queries, the identification of usage patterns, and suggestions for optimization; it also allows for the tagging of business dimensions based on functions or actions. The roadmap still indicates that these capabilities have not yet been implemented, and those responsible for deployment should consider them as experimental features or planned capabilities that need to be verified.

Verified capabilities and capabilities pending verification

Working principle

1. The team deployed Fiorino.AI backend and PostgreSQL within its own infrastructure.
2. Create a Realm and generate an API Key for that product or tenant.
3. AI applications call the model services to obtain the actual input and output tokens as well as model information.
4. The application sends the anonymous user ID, Token, provider, and model to the usage tracking interface.
5. Fiorino.AI calculates the usage cost based on the model price and any custom surcharges.
6. The dashboard aggregates trends by user, model, time, and other dimensions.
7. The team compares internal records with the provider’s invoices, and adjusts prices or corrects any omissions.
8. When customer billing is required, the verified usage amount is passed on to an independent billing and reconciliation process.

Deployment tutorial

Start the backend using Docker.

1. Prepare an independent PostgreSQL database and create application accounts with restricted permissions.
2. Store database connection details securely; do not submit passwords to the code repository.
3. Pull the official container image and map the application ports to the controlled network.
4. Connect to PostgreSQL using the DATABASE_URL environment variable.
5. After startup, check the database migration, health status, and API documentation.
6. Set up a reverse proxy, data encryption, authentication, and access logs.
7. Create a test Realm and API Key, and send only simulated usage data to complete the verification.

Build the frontend

1. Obtain the official frontend source code and set up a Node.js environment that meets the project’s requirements.
2. Install the dependencies and configure your own backend API address in the environment file.
3. In development mode, check the login, dashboard, Realm, and API Key pages.
4. Run static checks and production builds, and address security-related alerts.
5. Deploy the build results to a static service and restrict the backend channels that are allowed to access them.
6. Check the pages for mobile dimensions, dark mode, error states, and insufficient permissions.

Connect to AI applications

1. Create separate Realms and API Keys for each environment and product.
2. On the server side, the actual amount of tokens returned by the model provider is read.
3. Use a stable external ID that does not allow direct identification of the user.
4. Call the usage tracking endpoint and pass in the input Token, output Token, provider, and model.
5. Set secure retries for timeouts and failures to prevent duplicate counting.
6. Regularly sample and compare application logs, Fiorino.AI, and provider invoices.
7. Revoke and rotate them immediately in the event of a key leakage or staff change.

Which users are it suitable for

• AI SaaS development team: View model costs and gross profits by end user.
• Companies that prioritize self-hosting: keep cost records in their own databases.
• Multi-model application: Provides a unified way to compare the token consumption of different providers and models.
• Pay-as-you-go products: Provide auditable usage records for the subsequent billing system.
• Platform Engineering Team: Establishes a unified cost center for various internal AI functions.
• Open-source contributors: Improved the FastAPI backend, the React frontend, and the deployment documentation.

Typical use cases

• Identify whether a small number of users are consuming the majority of the model’s budget.
• Compare the unit cost of using different models for the same function.
• Charge LLM fees based on product functionality, actions, or tenant allocation.
• Estimate the average user cost and gross profit margin before designing the package.
• Provide enterprise customers with usage details and internal audit records.
• Abnormal tokens, error loops, or suddenly longer prompt texts are detected.
• Pass the validated model usage to the existing billing system for charging.

Product advantages

• Both the backend and frontend have their source code made available publicly, allowing users to examine the implementation and deploy it on their own.
• The fields for integrating with REST APIs are simple, making it suitable for adding records to existing AI applications.
• Use anonymous external IDs to reduce the need to transmit names and email addresses directly.
• It supports multiple providers and models, and is not tied to any specific LLM service.
• The React dashboard provides a centralized view of tokens, costs, and trends.
• The Apache 2.0 license permits modification and distribution under certain conditions.
• Docker reduces the barriers to local testing and deployment of backend systems.

Usage restrictions and risks

• The project is small in scale, and the official repository receives only a limited number of signals of interest and contributions.
• The most recent public updates for both the backend and frontend date back to July 2025, with limited activity in terms of maintenance.
• The warehouse does not have an official release; version upgrades and rollbacks must be managed manually.
• The roadmap was last updated in November 2024, and many of the promotional features are still shown as unfinished.
• Model prices change frequently, and an outdated cost table can lead to incorrect calculations of profits and quotas.
• Retries, timeouts, or improper concurrent processing may result in duplicate or missing usage records.
• Anonymous user IDs are not automatically anonymized; it is still possible to identify individuals through business-related mappings.
• Self-hosting means that the person who deploys the system is responsible for the database, backups, monitoring, keys, and security repairs.
• Stripe’s billing, quota management, Cost Analyst, and compliance tools cannot be assumed to be available for use merely based on documentation.
• The README file on the frontend incorrectly states that the license is GPL v3, whereas the actual LICENSE file specifies Apache 2.0.
• There are no publicly available details regarding service levels, corporate support, privacy policies, or security certifications.
• The project does not replace the cloud service billing; it is necessary to reconcile it with the provider’s bills on a regular basis.

Price and usage costs

As of August 22, 2026, Fiorino.AI does not offer any public commercial hosting packages. The source code can be used freely under the Apache 2.0 license, but self-hosting still incurs costs related to infrastructure, development, and maintenance.

Free and open-source solutions do not mean zero-cost services. In a production environment, it is still necessary to take into account factors such as highly available databases, log storage, data retention, dependency upgrades, key rotation, and the effort required from engineering staff.

APIs and Integration

The backend of Fiorino.AI offers REST APIs as well as interactive interface documentation. The typical process for integration involves creating a Realm, generating an API Key, and then using the usage tracking endpoint to record the external user ID, Token, provider, and model.

Open source and licenses

The actual LICENSE files in both the backend and frontend repositories are under the Apache License 2.0, which permits use, modification, and distribution under the conditions of complying with the license, retaining notices, and indicating any modifications made. The license does not grant rights to use trademarks, nor does it provide any warranty regarding the quality of the software.

The README file at the beginning of the project specifies GPL v3, but both the LICENSE file in the repository and GitHub’s license indicator indicate Apache 2.0. Due to this discrepancy in the documentation, it is necessary to ask the maintainers for clarification before redistributing the project or integrating it commercially, and the decision should be based on the results of legal review.

Privacy and security

Fiorino.AI emphasizes the use of anonymous user IDs and self-hosting, but this does not automatically ensure compliance with privacy regulations. The deployer has control over the database, logs, interfaces, and backups, and therefore bears most of the responsibility for data protection.

• Do not include names, email addresses, the original prompt text, or business secrets directly in external_id.
• It is necessary to determine whether the tracking interface requires the receipt of the message content; if only usage data needs to be transmitted, this should be done on a minimal scale.
• The database utilizes separate accounts, minimal permissions, encrypted transmission, and static encryption.
• API Keys are stored only on the server or in a key management system, with records kept of their rotation and revocation.
• Restrict public access to API documentation, the administration panel, and the database.
• Set retention periods, deletion rules, export options, and tenant isolation policies for usage records.
• The review takes into account the version being used, security alerts, and the sources from which container images are obtained.
• Establish idempotent, reconciliation, error-correction, and audit processes before using them in customer bills.

Basic information

Recommendation score

Recommendation score: 3.8 / 5. Fiorino.AI offers a clear framework for tracking open-source costs; its API fields are simple, and Docker and PostgreSQL make it easy for development teams to test the solution in their own environments.

The main shortcomings are a weak signal for project maintenance, the absence of an official release version, discrepancies between the roadmap and the features that are advertised, as well as conflicts in the licensing documentation for the front-end components. It is more suitable for engineering teams willing to work with code and improve their production capabilities; it is not appropriate as a ready-to-use enterprise service that requires no maintenance.

Frequently Asked Questions

What does Fiorino.AI do?

It tracks the amount of tokens used by each anonymous user and by each model in AI applications, calculates the associated costs, and provides analysis through a dashboard. Teams can also use these verified records for setting quotas or for customer billing.

Is Fiorino.AI free?

The source code is available freely and openly, with no publicly listed pricing for hosting services. Costs related to servers, PostgreSQL, model calls, as well as monitoring and maintenance must be borne by the user themselves.

Which models are supported?

The interfaces are recorded by provider and model name, and they are not tied to any specific platform. The actual cost calculation depends on whether the price list for the models in use is complete and up to date.

Can costs be tracked by user?

Yes, anonymous users can be identified using external_id. Do not use names or email addresses as identifiers, and ensure that the mapping relationships within the business system are properly protected.

Can it be connected directly to Stripe for billing?

The project’s promotional materials and README files mention billing based on Stripe usage, but the old roadmap still lists this feature as unfinished. Before it can be used in production, the current code must be reviewed, and tests related to actual billing, refunds, and reconciliation must be carried out.

Is the AI Cost Analyst available yet?

Official descriptions classify it as a capability, but the roadmap still shows it as unfinished. One should rely on the actual interface and APIs after deployment, rather than relying on assumptions in advance.

How to deploy?

The backend can be operated by connecting to PostgreSQL through Docker, while the frontend needs to be developed separately after the address of the backend is specified. In a production environment, it is also necessary to implement encryption for data transmission, access control, backup mechanisms, and monitoring systems.

Are APIs provided?

A REST API is provided, which allows the use of API keys to record tokens, providers, models, and anonymous users. The official client SDK is still part of the roadmap.

Is Fiorino.AI open source?

Yes, the source code for both the backend and the frontend is made available publicly. The LICENSE files in both repositories are of the Apache 2.0 type.

Why does the license need to be confirmed again?

The README file on the frontend indicates GPL v3, but the actual LICENSE file specifies Apache 2.0. This has little impact when using it internally; however, clear clarification is required before redistributing it or integrating it into commercial products.

Is the project still under maintenance?

The most recent public updates for both the backend and frontend were in July 2025, and no official releases have been made. It is possible to try it out, but one should not assume that there will be ongoing maintenance or corporate support.

Can it replace the invoice from the model provider?

It cannot be a complete substitute. It is used for internal management of consumption and costs, and it is necessary to regularly compare it with the actual invoices provided by the model supplier.

Summary

Fiorino.AI is suitable for AI product teams that wish to keep track of the costs associated with using LLMs on the end user side, while still maintaining the ability to host these systems locally and to review their source code. It offers backend interfaces, PostgreSQL storage, and a visual interface, making it an ideal starting point for cost management.

Before its official adoption, it is necessary to test the roadmap functionality, licensing, key security, duplicate counting, and price list updates. It is better to consider it as an expandable open-source foundation, rather than a fully functional product that already boasts complete enterprise billing and compliance features.