Expertise · Access to AI models
We place a single entry point between the company's applications and model providers, compatible with the OpenAI interface. From there, separate keys are issued per project, with a spending cap, a list of permitted models and a list of IP addresses, and consumption is visible per key.
Already builtThe gate runs and can be checked from the outside today, without taking our word for it: the public model catalogue returns 200 and lists 106 marked active models, and the model query without a key returns 401. Under it are two in-house implementations: the billing and administration service (98 TypeScript files), which issues keys, synchronises limits with the gate and keeps the registers, and our assistant platform, which takes speech recognition and synthesis into production through the same gate, not directly to the provider. The reservations, stated here and not in the footnote: the catalogue changes from hour to hour, so any figure is written with the date next to it; there is no Anthropic model in the gate today, although our own README promises otherwise; and the automatic sending of the invoice to the state system remains in trial mode until the certificate is installed.
The problem appears the second time, not the first. The first integration with a model provider is simple: one key, one library, done. The fifth application, the third team and the second invoice in foreign currency are the moment when nobody can answer three simple questions any more — who is consuming, how much, and what happens if a script runs out of control on a Saturday night. The Gateway solves exactly that: applications no longer talk to providers, they talk to a single entry point that has the same interface as the OpenAI API, so in most libraries you change the base address and the key, not the code.
What you can check yourself, right now, without an account: the gateway’s public model catalogue responds and says what it contains. At today’s check there were 106 models, all marked active — 77 text models, of which 48 declare reasoning capabilities, 10 audio, 7 image, 7 real-time, 3 vectorisation and 2 video. The same check made by a colleague an hour and a half earlier returned 107. That is why the figure is always written with the time next to it, and on the site it should be read from the endpoint, not typed by hand.
Cost control is not a dashboard, it is a brake. A key has a spending cap, a cap period chosen from four, a list of allowed models, a list of accepted IP addresses — up to twenty, IPv4, IPv6 or blocks — and a blocking flag. When a cap is exceeded, the key is blocked automatically and the reason is written on it, so the interface can say why, instead of showing a silent state. There is also a correction that few people make: models that “think” before replying consume more at the provider than the gateway sees, so the raw cap sent below is divided by a reasoning factor calculated as the median over the user’s last thirty days, limited between one and twenty. Without this correction, a spending cap would be decorative exactly on expensive models.
The local part. The exchange rate is read from the official XML file of the National Bank of Moldova for the current day, with a five-second timeout and a fallback value from configuration when the source does not respond — a gateway is not allowed to stop because an exchange-rate site is unavailable. The tax invoice is built as XML and stored, with a cycle of states from draft to accepted or rejected. The actual submission to the state system is done with a certificate; as long as the certificate is not installed, the service remains in trial mode: the XML is generated and saved, but not sent. That is the real state and we write it, because it is the difference between “we have a tax invoice” and “we have everything needed to send it”.
What it covers
Applications keep the libraries they are written with and change the base address and the key. The gateway requires a key: querying the model list without an authorisation header returns 401, checked today from outside. The service availability check responds publicly, with security headers set (`X-Frame-Options: DENY`, content policy that forbids framing).
Each key has an alias derived from the user and the given name, a spending cap, a cap period chosen from one day, seven, thirty or ninety, a list of allowed models and current spending. The key is created through the gateway’s administration interface and persisted locally, so the two do not drift apart.
When the cap is exceeded, the key is blocked and the moment of application, the start of the period and the reason remain on it. The code comment says why it was added: so the interface can show why a key is blocked, instead of a silent state that nobody can explain.
Up to twenty entries per key, each IPv4, IPv6 or CIDR block, validated on input. The list does not remain only in our database: it is forwarded to the gateway, which applies it effectively on every request.
Models that produce thought steps before a reply are billed by the provider for those steps, but the gateway does not see them. The raw cap sent to the gateway is calculated by dividing the client cap by the applied margin and by a reasoning factor — the median observed over the last thirty days for that user, with a minimum threshold of one and a limit of twenty. Without it, a cap would be respected on cheap models and exceeded exactly on expensive ones.
The exchange rate is read from the official XML of the National Bank of Moldova for the current date, with a timeout after five seconds. If the source does not respond, the fallback value from configuration is used. Conversion is not an office-made approximation; it is a reading from a public document, with defined failure behaviour.
The document is generated as XML from a paid transaction, stored and moved through states: draft, pending sending, sent, accepted or rejected. There is a manual trigger and a scheduled daily one for users who have the fiscal code completed.
The log is append-only and covers 64 named event types — successful and failed sign-ins, two-step verification, password rotations, key creation, blocking, deletion, cap changes. The export requested by the General Data Protection Regulation produces an archive with tables linked to a user, JSON for nested data and CSV for large data, with an exception written in code: from keys, only the metadata is exported, never the token material.
Our assistants platform routes voice recognition and synthesis to production through the same gateway, not directly to the supplier, with the version suffix enforced in code. When the gateway goes down, we go down too — which is the only arrangement under which it is worth recommending it to anyone else.
What it looks like
Usually personal keys show up in configuration files, two supplier accounts on the same team, and at least one service that no one remembers is still running. The result is a list with application, key, model, estimated volume — the point from which caps can be discussed.
The base address and the key are changed in one place, responses are compared with the previous ones, and the error flow is checked: non-existent model, blocked key, exceeded cap, supplier unavailable. Only after the first application behaves identically do the others follow.
One key per application and per environment, with cap, period, list of allowed models and, where servers have fixed addresses, list of IPs. The cap is calculated with the correction for models that reason; otherwise it is a number that reassures without stopping anything.
Rate from the official source, invoice generated from the paid transaction, state cycle. It is explicitly checked whether the sending certificate is installed: without it, the documents are built and remain pending. It is a distinction that accounting will discover anyway, better in the first week.
Who can create keys, who can raise a cap, what is logged, how to request a user's data export and what to do on the day a key ends up where it should not.
The data
The questions anyone with a data protection officer would ask — asked here before they do.
A case
The situation
The usual situation in a company that has passed the first integration: several applications call models with borrowed keys, consumption appears on a single foreign-currency invoice, and no one can say which application produced last week’s peak.
What we built
We put the gateway in front of the applications, with an interface compatible with the library they were already using, and issued separate keys per project. Each key received a limit, a limit period, a list of allowed models and, where the servers had fixed addresses, an IP list enforced by the gateway. The gross limit sent below is calculated with the correction for reasoning models: it is divided by the applied margin and by the user’s median factor over the last thirty days, capped between one and twenty.
What came out
Consumption is read per key, so per application. On exceedance, the key blocks itself and the reason remains written on it, so the question “why is it no longer working” has an answer without anyone opening the logs. Billing in lei is done using the official exchange rate read from the day’s XML. From outside, it can be checked at any time that the gateway requires a key: the list of models without authorisation returns 401.
What the case does not say
A single entry point is also a single point of failure — from the outset, applications are designed for what they do when the gateway does not respond. The model catalogue changes from one hour to the next, so any printed list ages; on the day of the check there was no Anthropic model, although our older documentation still promised it. And the automatic sending of the invoice to the state system depends on a certificate installed on the server: without it, the documents are built and wait.
Questions
At today’s check, 106, all marked active: 77 text models (48 of them declare reasoning), 10 audio, 7 image, 7 real-time, 3 vector and 2 video. The catalogue is public and can be read without an account. We say “at today’s check” because a colleague measured 107 an hour and a half earlier, on the same day. A number without a time next to it means nothing.
No, none. We filtered the live catalogue by all names in that family: zero results. We say this although our own README promises something else — the document is old, the gateway is the truth. Gemini models, however, are present, as are the speech synthesis of a specialised provider and the video models.
In the usual case, no: the gateway exposes the OpenAI-compatible interface, so the base address and the key change. The cases that need attention are those that use the specifics of a particular provider — we have already met one, where the Azure-specific library was building addresses that the gateway did not understand, and it was resolved by switching to the standard client. That is why the first application moves by itself, not all at once.
With a limit per key and a limit period, plus automatic blocking on exceedance, with the reason written on the key. In addition, the limit takes into account the fact that reasoning models cost more from the provider than the gateway sees: the gross limit is divided by a factor calculated as the user’s median over the last thirty days. Without this correction, limits work on cheap models and fail on expensive ones.
None expressed in figures, and that is a deliberate position. We do not have an uptime collector in the code, and the source our own materials cite as the calculation method does not respond in today’s check. What can be shown now: the service liveliness check responds publicly, and the status page makes live probes, without history. We could write a percentage at any time; it would be a contractual commitment disguised as a measurement.
Conversion from foreign currency is done at the official National Bank rate, read from today’s XML, with a timeout after five seconds and a fallback value if unavailable. The invoice is built as a tax document and goes through a cycle of states. Automatic submission to the state system requires a certificate: as long as it is not installed, documents are generated and remain pending, without being sent. We check together which regime the system is in on the day we start, because it is a server setting, not a code setting.
Consumption metadata: the key, the model, the volume, the cost, the moment. The gateway counts, not archives conversations; what is kept from the content is the decision of the application that generates it, and if the application is ours, it is written into the contract. Exporting a person’s personal data produces an archive with what is linked to them, and from keys it exports metadata, never the token material.
They are declared in writing, by name, because they become sub-processors for the data that passes through them. There are public pages for sub-processors, the processing and data protection agreement, checked today. A gateway that hides providers from the data controller does not solve a compliance issue, it moves it deeper.
The applications that depend on it go down, including ours — our assistant platform routes speech recognition and synthesis through the same gateway. There is no point pretending otherwise: it is the trade-off of a single entry point, paid for in exchange for control, separate keys and a single bill. For critical applications, it is discussed from the start what happens in its absence — degraded response, queue or clean error — because that is a behaviour to be designed, not hoped for.
9 of them are code and files from our repositories. We don't publish their name or line: together, on a single page, they would describe too precisely how systems that aren't only ours are built. We go through them with you, in the repository, on request — verification stays possible, it just happens in a conversation.
Tell us about your process. Together we decide what is worth building, what we can connect, and how we check the result.