3.000 free requests a month · no card

Public data that finally connects to itself.

We import the datasets at source, normalise them, link them and serve them as a versioned REST API. You make a request and get validated JSON — no scrapers, no CSVs to watch, no classifications to maintain.

The anatomy of any response
GET /{modul}/v1/{resursă}?pagina=1
Authorization: Bearer ••••••••

{
  "data":  [ … ],   // the only thing that differs
  "meta":  { pagination, updated },
  "links": { next }
}
200 OKapplication/jsoncache HIT
If-None-Match"a3f9c1e0"
304

Not Modified · 0 off your quota

x-ratelimit-remaining59 / 60

The limit is in every response; you do not find out when you cross it.

One token for the whole catalog
The same envelope shared errors and pagination
ETag everywhere 304 costs nothing
OpenAPI per module generate a client in your language
Hosted in the EU imported, not brokered
01 Why we exist

The sources do not connect. That is why we exist.

Every public register was built as if it were the only one: a different format, a different rhythm, no shared key. We reconcile once and keep it stable while the sources shift underneath us.

National register CSV · monthly
Official web service API · 1 req/s
Open data portal XLSX · yearly
Periodic bulletin PDF · weekly
Statistical database tables · variable
Hand-published list HTML · “when possible”
oneapi pipelineany dataset
A
Consolidate Separate files become one object with a documented schema.
B
Normalise Local conventions become explicit rules, applied everywhere.
C
Link We rebuild the missing keys. Better empty than invented.
D
Complete Only what can be derived. Never estimated.
verification→ publication→ changelog
One contract

The same response, whatever the source.

  • one token
  • the same error format
  • the same pagination
  • limits in the headers
  • versioning per module
Different shape, rhythm and keys The same four operations Stable over time
02 What you solve

Six things any dataset does inside your product.

However different the content, it comes down to confirming, suggesting, completing, calculating, grouping or saying how things were. Each of them, and in bulk, in a single call.

A Validation

You confirm that an entered value really exists in the official set, while fixing it still costs one click.

B Suggestion

The field offers results from the official set as the user types. What lands in your database is a chosen value, not free text.

C Completion

One identifier brings the rest of the information with it. The data goes in spelled correctly from the start.

D Calculation

Sometimes you need the result, not the record. It arrives already calculated, with the rules applied correctly and kept current.

E Grouping

Reports are built on stable codes, not on hand-typed names. Three spellings land on the same row.

F Point-in-time queries

Not just how it is now, but how it was on a given date. For any decision that has to be justified later.

03 Catalog

The catalog grows. Your integration stays the same.

Independent modules, each with its own page, documentation and version. You pick only what you need; a new module does not mean new plumbing.

See all modules
one tokenoneapi
Finance Companies Administrative Tax compliance Environment Energy Fuels Identifiers Telecom Utilities
04 For developers

One token and the HTTP client you already have.

You install nothing. The envelope, the errors and the pagination are identical everywhere, and the OpenAPI spec generates a client in your language.

# any module, the same shape
curl "https://oneapi.ro/api/{module}/v1/{resource}" \
  -H "Authorization: Bearer $ONEAPI_TOKEN" \
  -H "Accept: application/json"

# second time round, nothing off your quota
curl "https://oneapi.ro/api/{module}/v1/{resource}" \
  -H "Authorization: Bearer $ONEAPI_TOKEN" \
  -H 'If-None-Match: "a3f9c1e0"'
# → 304 Not Modified
// one client, reused for every module
$oneapi = Http::baseUrl('https://oneapi.ro/api')
    ->withToken(config('services.oneapi.token'))
    ->acceptJson()
    ->retry(2, 200);

$result = $oneapi
    ->get("/{$module}/v1/{$resource}", ['pagina' => 1])
    ->throw()
    ->json('data');
const oneapi = async (path) => {
  const res = await fetch(`https://oneapi.ro/api${path}`, {
    headers: { Authorization: `Bearer ${process.env.ONEAPI_TOKEN}` },
  });
  // the same rate-limit handling, whichever module it is
  if (res.status === 429) {
    await sleep(Number(res.headers.get('Retry-After')) * 1000);
    return oneapi(path);
  }
  return res.json();
};
client = httpx.Client(
    base_url="https://oneapi.ro/api",
    headers={"Authorization": f"Bearer {os.environ['ONEAPI_TOKEN']}"},
    timeout=5.0,
)

# the same function, any module
def fetch(module: str, resource: str, **params) -> list:
    r = client.get(f"/{module}/v1/{resource}", params=params)
    r.raise_for_status()
    return r.json()["data"]
CacheETag · If-None-Match
200first request−1 off your quota
304the data has not changed0 off your quota
Versionsper module
v1 active v2 announced ≥ 12 months in parallel
05 Stability

What you build today has to still work in two years.

90days

Notice before breaking changes

Announced publicly before anything happens.

12months

The old version stays up

At minimum, from the announcement. We do not break someone’s production on a Tuesday morning.

0reuses

Permanent identifiers

A code, once assigned, belongs to that record forever.

1field

Data age, visible

Every response says how old the dataset is. You do not have to guess.

07 In short

What a data API platform is

A data API delivers structured information on demand, over an HTTP request, instead of a file you download by hand or a scraper you wrote yourself. Rather than maintaining a monthly import from a CSV whose columns keep moving, you query a versioned endpoint and get validated JSON.

oneapi groups several datasets under one technical contract: the same response structure, the same error codes, the same pagination and the same token authentication. Adding a new module does not require rewriting the integration you already have.

From files that change, into an endpoint that does not.
Who it is for

For teams building address autocomplete, billing flows that validate a VAT number at checkout, applications that need official classifications, or any product that depends on data maintained by someone else. The catalog covers local and international datasets and grows with the requests we get.

Integration

Authentication uses a Bearer token generated from the dashboard, limited to the modules you tick. There is no mandatory SDK: any HTTP client works, and the OpenAPI spec generates a client in your language.

Performance and availability

Most requests are served from cache, with ETag and Cache-Control on every response, so a well-written client spends quota only when the data has actually changed. The infrastructure is hosted in the European Union.

Transparent pricing

The free plan includes access to every module, with no card and no limited trial. Paid plans raise the volume and the per-second limit, not the number of users.

See the full comparison →
Documentation

Every module has a reference generated from the code, examples in five languages and a console you can try with your own token.

Open the documentation →
Declared sources

Every dataset states its provenance and licence publicly. The data comes from official public sources, and the age of the set is visible in every response.

Sources and licences →

From new account to first response, in minutes.

3.000 requests a month, the whole catalog, no card.