← All integrations
Built to connect

The Ribbiot API.For your systems.

In build, first release proposed for December 2026

The Ribbiot API is in build: one documented, versioned way for the systems you already run to read and write your job record. Access will be issued by Ribbiot, company by company.

Status addressOpen, no key
GET /status

200
{
  "status": "up",
  "message": null,
  "updatedAt": "2026-11-13T04:14:24.238Z"
}

A real answer, read on November 13, 2026.

Getting started

Introduction

The Ribbiot API is one documented, versioned way for the systems you already run to read and write your job record. It is REST over HTTPS, with JSON in and out.

Why it mattersBuilt so job data reaches the tools finance and reporting use without exports and re-keying. Ribbiot feeds your accounting system. It does not replace it.

In buildFirst release proposed for December 2026. This reference describes that release as it is being built, so paths, fields and codes can still change before it ships.

  • Records, one at a timePeople first, then customers and vendors, then jobs and tasks, purchase orders and invoices.
  • Your mappingYour system maps Ribbiot's records to its own. Nothing in the API is shaped around one accounting product.
A first callExample
# the base address comes with your key
curl "$RIBBIOT_API/v1/users?is_active=true" \
  -H "Authorization: Bearer $RIBBIOT_KEY"
Its answerExample
200
{
  "data": { "users": [ ... ] },
  "pagination": {
    "next": "/v1/users?cursor=eyJzb3J0...",
    "prev": null
  }
}

Getting access

Four steps, from the first question to your first live call.

Why it mattersAccess will be issued by Ribbiot, company by company, for that company's own record. There is no sign-up page and no key to generate yourself.

  1. 01 / AskAsk for access. Tell us the system you want to connect and the records you need.
  2. 02 / Set upRibbiot sets your company up and hands your team its keys.
  3. 03 / BuildBuild against the sandbox with test keys and sample data.
  4. 04 / Go liveGo live with read access first, then write.

Ask for access

Environments

Two environments, kept apart: a sandbox to build against and your live record.

Why it mattersThe prefix tells anyone reading a settings file which record a key reaches, and it gives a secret scanner one pattern to catch a key that has slipped into code.

  • SandboxTest keys begin rbbt_test_. They work on sample data and never touch your live record.
  • LiveLive keys begin rbbt_live_. They reach your company's record and nothing else.
  • Base addressEach environment has its own base address, issued with its key. The version is part of the path, so the base address carries none.
KeysShape
# sandbox
rbbt_test_<your test key>

# live
rbbt_live_<your live key>

Authentication

Every call under /v1 carries your key in one header. Nothing else is read: no other header, no parameter in the address.

Why it mattersThe key is all that stands between another system and your record. These rules keep one leaked or forgotten key from becoming a way in.

  • One company per keyA key reaches one company's record and nothing else.
  • Shown onceA key is shown once, when it is issued. Keep it where your secrets live.
  • Never in the addressA key sent as ?api_key= or ?key= is refused with 400 and never read. Treat that key as leaked and ask for a new one.
  • One answer for a bad keyA missing, unknown, switched-off or expired key gets the same 401, so guessing teaches nothing about a key.
  • Rotation without downtimeThe old key and the new key both work while you switch.
  • Off switchA key can be switched off at once.
HeadersShape
# you send
Authorization: Bearer <your API key>

# every answer carries
X-Request-Id: <request ID>
RateLimit-Remaining: <requests left>
A refused keyExample
401
{
  "errors": [
    {
      "code": "UNAUTHENTICATED",
      "message": "Invalid or missing API key"
    }
  ],
  "request_id": "0b9f6a1e-5c4d-4e3f-9a2b-1c0d9e8f7a6b"
}

Permissions

Each key carries scopes, set record by record: read, or read and write.

Why it mattersA reporting tool that only reads should never hold the power to change a person. Scopes keep each connection to the least it needs.

Scope

  • users:read

    List people and fetch one.

  • users:write

    Create, replace and deactivate people.

  • roles:read

    List the roles your key may assign.

Write covers POST, PUT and DELETE. A call outside the key's scopes answers 403 INSUFFICIENT_SCOPE.

Requests and answers

JSON in, JSON out. A body you send is application/json and no larger than 1 MB.

Why it mattersOne envelope to parse, and no guessing whether a field is missing or empty. A mapping written once keeps working.

  • Three shapesAnswers about records come in three shapes: one record, a list, or an error.
  • Plain namesThe fields of a record are snake_case. Times are ISO 8601 in UTC, to the millisecond, ending in Z. IDs are UUIDs.
  • Nothing left outA field with no value is sent as null, never dropped, so every record has the same keys.
  • Strict writesA write names every field and no unknown ones. A missing or extra key answers 422.
One recordShape
{
  "data": {
    "<record>": { ... }
  }
}
A listShape
{
  "data": {
    "<records>": [ ... ]
  },
  "pagination": {
    "next": "<path>",
    "prev": null
  }
}
An errorShape
{
  "errors": [
    {
      "code": "NOT_FOUND",
      "message": "..."
    }
  ],
  "request_id": "..."
}

Paging

Lists come a page at a time. People come 100 to a page, oldest first.

Why it mattersThe cursor marks a place in the list, so a load that runs while people are being added neither skips a person nor reads one twice.

  • Follow nextpagination.next and pagination.prev are ready-made paths. Follow next until it is null.
  • Opaque cursorPass the cursor back exactly as it came. A cursor the route did not issue answers 400 INVALID_CURSOR.
  • Filters travel with youThe cursor does not keep filters. Send the same filters with every page, or the next page comes back unfiltered.
  • Fixed page sizelimit and page_size are accepted and ignored.
Two pagesExample
# first page
GET /v1/users?is_active=true

# its answer ends with
"pagination": {
  "next": "/v1/users?cursor=eyJzb3J0...",
  "prev": null
}

# next page: the cursor, and the filter again
GET /v1/users?cursor=eyJzb3J0...&is_active=true

Errors

Every answer outside the 200s has one shape: a list of errors and the request ID.

Why it mattersAn overnight sync has nobody watching it. A code it can branch on turns most failures into a retry or a clear fix, and the request ID settles the rest.

  • codeA fixed word your system can act on.
  • messageA sentence a person can read.
  • pathThe failing field, from the root of the body, on a validation error. One entry for each failing field.
  • request_idThe same value as the X-Request-Id header. Give it to support and the call can be traced.

Codes

400
  • BAD_REQUESTThe request cannot be read as sent.
  • INVALID_JSONThe body is not valid JSON.
  • INVALID_CURSORThe cursor is malformed or was not issued by this route.
401
  • UNAUTHENTICATEDThe key is missing, unknown, switched off or expired.
403
  • INSUFFICIENT_SCOPEThe key does not carry the scope this route needs.
  • CONSUMER_SUSPENDEDThe key is valid and your company's access is suspended.
  • USER_NOT_MANAGEABLEThe person cannot be changed through the API. Do not retry.
404
  • NOT_FOUNDAn unknown route, or a record that is not in your account.
405
  • METHOD_NOT_ALLOWEDPATCH, on any route, or a method this route does not take.
409
  • USER_CONFLICTAn email, phone number or external ID already belongs to an active person. One entry for each field.
  • USER_INACTIVEThe write matched an inactive person. Send is_active: true to bring them back.
  • CONFLICTThe write collides with a record that already exists.
413
  • PAYLOAD_TOO_LARGEThe JSON body is over 1 MB.
415
  • UNSUPPORTED_MEDIA_TYPEA body was sent without application/json.
422
  • VALIDATION_ERRORA value failed validation. One entry for each field, with path.
  • INVALID_REFERENCEThe body names a branch, division or occupation outside your account.
  • ROLE_NOT_ASSIGNABLEA role in roles cannot be assigned with this key.
429
  • RATE_LIMITEDOver your limit. Wait the seconds in Retry-After.
  • TOO_MANY_REQUESTSOver the limit on an open route.
500
  • INTERNAL_ERRORAn unexpected error. The body carries no detail; the request ID finds it.
502
  • BAD_GATEWAYA service behind the API answered with an error. Safe to send again.
503
  • SERVICE_UNAVAILABLEMaintenance, or a service behind the API did not answer in time. Safe to send again.
Two fields collideExample
409
{
  "errors": [
    {
      "code": "USER_CONFLICT",
      "message": "One or more values are already used by an active person.",
      "path": ["email"],
      "id": "7c9e6679-7425-40de-944b-e07fc1f90ae7"
    },
    {
      "code": "USER_CONFLICT",
      "message": "One or more values are already used by an active person.",
      "path": ["phone_number"]
    }
  ],
  "request_id": "0b9f6a1e-5c4d-4e3f-9a2b-1c0d9e8f7a6b"
}

Rate limits

Every request counts against a fair-use limit, counted in fixed 60-second windows.

Why it mattersEvery response tells your system how much room is left, so a large first load can pace itself and finish.

  • Headers on every answerRateLimit-Limit, RateLimit-Remaining, RateLimit-Reset and RateLimit-Policy say how much room is left.
  • Over the limitThe answer is 429 with Retry-After, in seconds. Wait that long and send again.
  • Set for your companyYour limit comes with your key, and the headers show it.
  • Open routes apartStatus, the reference document and the changelog are limited by caller and never spend your key's allowance.
Limit headersExample
RateLimit-Limit: 300
RateLimit-Remaining: 287
RateLimit-Reset: 41
RateLimit-Policy: 300;w=60
Over the limitExample
429
Retry-After: 41
{
  "errors": [
    {
      "code": "RATE_LIMITED",
      "message": "Rate limit of 300 requests per minute exceeded"
    }
  ],
  "request_id": "0b9f6a1e-5c4d-4e3f-9a2b-1c0d9e8f7a6b"
}

Versions and change

The API is versioned from the first release, and it is built to run unattended.

Why it mattersAn integration is written once and runs for years. These rules are what let it run with nobody watching.

  • Versioned pathsPaths begin /v1. Additions never break what you built. A breaking change comes as a new version of that one endpoint.
  • Replace, never patchPUT sends the whole record. PATCH answers 405 on every route.
  • Safe to repeatSend the same record twice and you still have one. An identical body changes nothing.
  • Reference and changelogA machine-readable reference and a changelog are published with the API.
  • Audit trailIssuing a key, rotating it and changing its permissions are written to an audit trail.
  • Request IDs and loggingEvery request gets an ID you can give to support. Calls are logged. The contents and the keys never are.

People

In build

A person is anyone who can sign in to Ribbiot: someone in the field, someone in sales, someone in payroll. In paths and fields the record is called a user.

List people, look one up, add, update, deactivate and bring back, so your roster stays in step with your payroll or human resources system.

Why it mattersPeople change every week: a hire, a move to another branch, a departure. When your system of record sends each change, nobody is typed in twice and nobody stays active after they leave.

The person record

One shape for reading and writing. A read returns every field; a write sends the ones marked write, all of them, every time.

Why it mattersYour own employee number travels with the person as external_id, so your system and Ribbiot always mean the same person.

Fields

  • idstring, UUIDread

    Ribbiot's ID for the person.

  • created_at, updated_atstring, ISO 8601read

    When the record was made and last changed, in UTC.

  • external_idstring or nullread, write

    Your own key for the person. We recommend the employee number. Matching ignores case and surrounding spaces.

  • is_activebooleanread, write

    false once the person can no longer sign in.

  • first_name, last_namestringread, write

    Required on a write, and never blank.

  • preferred_namestring or nullread, write

    The name the person goes by.

  • emailstring or nullread, write

    Stored in lower case. A person needs an email or a phone number: it is how they sign in and receive their invite.

  • phone_numberstring or nullread, write

    Stored as E.164. Ten digits are read as a United States number; send other countries with a plus sign.

  • occupationsarray of { id, default, name }read, write

    What the person does on a job, used for quoting, scheduling and dispatch. One may be the default. name is read only.

  • branch{ id, name } or nullread, write

    The person's primary branch. name is read only.

  • divisionsarray of { id, name }read, write

    The divisions the person works in. name is read only.

  • rolesarray of stringread, write

    Role codes. On a write, the full list the person should hold.

A personExample
{
  "id": "7c9e6679-7425-40de-944b-e07fc1f90ae7",
  "created_at": "2026-09-08T14:03:22.115Z",
  "updated_at": "2026-11-02T09:41:07.530Z",
  "external_id": "E-10482",
  "is_active": true,
  "first_name": "Alex",
  "last_name": "Rivera",
  "preferred_name": null,
  "email": "alex.rivera@example.com",
  "phone_number": "+14155550100",
  "occupations": [
    { "id": "3d0f6c1a-...", "default": true, "name": "Operator" }
  ],
  "branch": { "id": "b2a4e8f0-...", "name": "North branch" },
  "divisions": [
    { "id": "5e1c9d7b-...", "name": "Field services" }
  ],
  "roles": ["crew-lead", "field-worker"]
}

List people

GET/v1/usersScope users:read

People in your account, 100 to a page, oldest first. Inactive people are included unless you filter them out.

Why it mattersLook a person up by your own employee number before you write, or page through the whole roster for a first load.

Query parameters

  • external_idstringoptional

    Exact match, ignoring case and surrounding spaces.

  • emailstringoptional

    Exact match, ignoring case and surrounding spaces.

  • is_activetrue or falseoptional

    true returns active people only, false inactive people only. Both when absent.

  • cursorstringoptional

    The token from pagination.next or pagination.prev.

Filters combine with AND. Any other parameter answers 422.

Answers

  • 200One page of people.
  • 400The request cannot be read: invalid JSON, or a cursor this route did not issue.
  • 401The key is missing, unknown, switched off or expired.
  • 403The key lacks the scope, your company's access is suspended, or the person cannot be changed through the API.
  • 422A value failed validation, or the body names something outside your account. One entry for each failing field.
  • 429Over the rate limit.
RequestExample
curl "$RIBBIOT_API/v1/users?external_id=E-10482" \
  -H "Authorization: Bearer $RIBBIOT_KEY"
AnswerExample
200
{
  "data": {
    "users": [
      {
        "id": "7c9e6679-7425-40de-944b-e07fc1f90ae7",
        "external_id": "E-10482",
        "is_active": true,
        "first_name": "Alex",
        "last_name": "Rivera",
        ...
      }
    ]
  },
  "pagination": { "next": null, "prev": null }
}

Create or update a person

POST/v1/usersScope users:write

Creates the person, or replaces the one who already holds this external_id.

Why it mattersOne call covers the hire and the correction. A nightly feed can send everyone again and only the changes are written.

  • No matchThe person is created, the call answers 201 and Ribbiot sends them an invite.
  • A matchThe person is replaced and the call answers 200. An identical body changes nothing.
  • Bringing someone backSend is_active: true with the email, phone number and external ID already on their record.
  • RolesEvery role you add or remove must be one your key may assign, and any other role the person holds must be sent back unchanged. Read the person first and send roles from that read.

Body

  • data.userobjectrequired

    The person record, every writable field. Unknown fields are refused.

Answers

  • 200A person with this external ID already existed. Their record as it now stands.
  • 201The new person.
  • 400The request cannot be read: invalid JSON, or a cursor this route did not issue.
  • 401The key is missing, unknown, switched off or expired.
  • 403The key lacks the scope, your company's access is suspended, or the person cannot be changed through the API.
  • 409The write collides with another person, or would change someone who is inactive.
  • 413The JSON body is over 1 MB.
  • 415The body was sent without application/json.
  • 422A value failed validation, or the body names something outside your account. One entry for each failing field.
  • 429Over the rate limit.
  • 502A service behind the API answered with an error. Safe to send again.
  • 503Maintenance, or a service behind the API did not answer in time. Safe to send again.
RequestExample
curl -X POST "$RIBBIOT_API/v1/users" \
  -H "Authorization: Bearer $RIBBIOT_KEY" \
  -H "Content-Type: application/json" \
  -d @person.json
person.jsonExample
{
  "data": {
    "user": {
      "external_id": "E-10482",
      "is_active": true,
      "first_name": "Alex",
      "last_name": "Rivera",
      "preferred_name": null,
      "email": "alex.rivera@example.com",
      "phone_number": "(415) 555-0100",
      "occupations": [{ "id": "3d0f6c1a-...", "default": true }],
      "branch": { "id": "b2a4e8f0-..." },
      "divisions": [{ "id": "5e1c9d7b-..." }],
      "roles": ["crew-lead", "field-worker"]
    }
  }
}
AnswerExample
201
{
  "data": {
    "user": {
      "id": "7c9e6679-7425-40de-944b-e07fc1f90ae7",
      "external_id": "E-10482",
      "is_active": true,
      "first_name": "Alex",
      "last_name": "Rivera",
      ...
    }
  }
}

Fetch a person

GET/v1/users/{id}Scope users:read

One person in your account, active or inactive.

Why it mattersRead before you write. A replace needs the roles the person holds today.

Path parameters

  • idstring, UUIDrequired

    Ribbiot's ID for the person.

An ID that is not in your account, or is not a UUID, answers 404, so an answer never says whether a record exists somewhere else.

Answers

  • 200The person.
  • 401The key is missing, unknown, switched off or expired.
  • 403The key lacks the scope, your company's access is suspended, or the person cannot be changed through the API.
  • 404No such person in your account.
  • 429Over the rate limit.
RequestExample
curl "$RIBBIOT_API/v1/users/7c9e6679-7425-40de-944b-e07fc1f90ae7" \
  -H "Authorization: Bearer $RIBBIOT_KEY"
AnswerExample
200
{
  "data": {
    "user": {
      "id": "7c9e6679-7425-40de-944b-e07fc1f90ae7",
      "external_id": "E-10482",
      "is_active": true,
      "first_name": "Alex",
      "last_name": "Rivera",
      ...
    }
  }
}

Replace a person

PUT/v1/users/{id}Scope users:write

Replaces one person with the full body and answers 200 with a fresh read of them.

Why it mattersYour system of record stays the authority. What it sends is what the person becomes, with nothing left over from an earlier edit.

  • Nothing changedA body that changes nothing answers 200 and writes nothing, so a nightly resend is safe.
  • Deactivatingis_active: false deactivates the person after any other change is applied.
  • Bringing someone backis_active: true brings an inactive person back when the email, phone number and external ID equal the stored ones.
  • Inactive stays as it isChanging anything else on a person who stays inactive answers 409 USER_INACTIVE.

Path parameters

  • idstring, UUIDrequired

    Ribbiot's ID for the person.

Body

  • data.userobjectrequired

    The person record, every writable field. Unknown fields are refused.

Answers

  • 200The person after the replace.
  • 400The request cannot be read: invalid JSON, or a cursor this route did not issue.
  • 401The key is missing, unknown, switched off or expired.
  • 403The key lacks the scope, your company's access is suspended, or the person cannot be changed through the API.
  • 404No such person in your account.
  • 405The method is not supported. PATCH is refused on every route.
  • 409The write collides with another person, or would change someone who is inactive.
  • 413The JSON body is over 1 MB.
  • 415The body was sent without application/json.
  • 422A value failed validation, or the body names something outside your account. One entry for each failing field.
  • 429Over the rate limit.
  • 502A service behind the API answered with an error. Safe to send again.
  • 503Maintenance, or a service behind the API did not answer in time. Safe to send again.
RequestExample
curl -X PUT "$RIBBIOT_API/v1/users/7c9e6679-7425-40de-944b-e07fc1f90ae7" \
  -H "Authorization: Bearer $RIBBIOT_KEY" \
  -H "Content-Type: application/json" \
  -d @person.json
AnswerExample
200
{
  "data": {
    "user": {
      "id": "7c9e6679-7425-40de-944b-e07fc1f90ae7",
      "external_id": "E-10482",
      "is_active": true,
      "first_name": "Alex",
      "last_name": "Rivera",
      ...
    }
  }
}

Deactivate a person

DEL/v1/users/{id}Scope users:write

Deactivates one person. They can no longer sign in, and a fetch returns them with is_active: false. Nothing is deleted.

Why it mattersWhen someone leaves, one call closes their sign-in, and everything they did stays on the record.

Path parameters

  • idstring, UUIDrequired

    Ribbiot's ID for the person.

Repeating the call for someone who is already inactive answers 204 again.

Answers

  • 204The person is inactive. No body.
  • 401The key is missing, unknown, switched off or expired.
  • 403The key lacks the scope, your company's access is suspended, or the person cannot be changed through the API.
  • 404No such person in your account.
  • 429Over the rate limit.
  • 502A service behind the API answered with an error. Safe to send again.
  • 503Maintenance, or a service behind the API did not answer in time. Safe to send again.
RequestExample
curl -X DELETE "$RIBBIOT_API/v1/users/7c9e6679-7425-40de-944b-e07fc1f90ae7" \
  -H "Authorization: Bearer $RIBBIOT_KEY"
AnswerExample
204

List assignable roles

GET/v1/rolesScope roles:read

Every role your key is allowed to give a person, sorted by code. The list is one page.

Why it mattersRoles decide what a person can see and do in Ribbiot. Read the list once and map your own job titles to it.

Each role

  • codestring

    The word you send in a person's roles.

  • namestring

    The role's name as people see it in Ribbiot.

  • descriptionstring or null

    What the role is for.

Answers

  • 200The roles your key may assign.
  • 401The key is missing, unknown, switched off or expired.
  • 403The key lacks the scope, your company's access is suspended, or the person cannot be changed through the API.
  • 429Over the rate limit.
RequestExample
curl "$RIBBIOT_API/v1/roles" \
  -H "Authorization: Bearer $RIBBIOT_KEY"
AnswerExample
200
{
  "data": {
    "roles": [
      { "code": "crew-lead", "name": "Crew Lead", "description": null },
      { "code": "field-worker", "name": "Field Worker", "description": null }
    ]
  },
  "pagination": { "next": null, "prev": null }
}

Open routes

These routes answer without a key.

Status

GET/statusOpen, no key

Whether the API is up, degraded or in maintenance, with a message when there is one. The status address answers today.

Why it mattersOne address your monitoring can watch, so a failed sync can be told apart from a planned pause.

The answer

  • statusup, degraded or maintenance

    Maintenance wins over degraded.

  • messagestring or null

    What is going on, when there is something to say.

  • updatedAtstring, ISO 8601

    When the status was last set.

RequestExample
curl "$RIBBIOT_API/status"
AnswerExample
200
{
  "status": "up",
  "message": null,
  "updatedAt": "2026-11-13T04:14:24.238Z"
}

Reference document

GET/v1/openapi.jsonOpen, no key

The machine-readable reference, as an OpenAPI 3.1 document: every route, field and answer.

Why it mattersGenerate a client from it, or check your own calls against it before they run.

RequestExample
curl "$RIBBIOT_API/v1/openapi.json"

Changelog

GET/v1/changelogOpen, no key

What changed, newest first. Markdown by default; send Accept: application/json for entries your system can read.

Why it mattersYour team hears about an addition from the API itself, and can watch for one in code.

RequestExample
curl "$RIBBIOT_API/v1/changelog" \
  -H "Accept: application/json"
AnswerShape
200
{
  "data": {
    "version": "<version>",
    "entries": [
      { "version": "<version>", "body": "..." }
    ]
  }
}

After people

Records that follow

Customers and vendors come after people, then jobs and tasks, purchase orders and invoices. Each keeps the conventions above: the same key, the same three answer shapes, the same paging and errors.

Why it mattersWhat your team learns on people carries over. Each new record is a mapping, with no new way of talking to learn.

  • Customers

    Create, read and update customers from your accounting system, matched on your own customer number.

    Carries: name, trading names, status, phone, email, website, notes, billing address, billing terms, salespeople.

  • Vendors

    Read and write vendor records, so a purchase order points at the vendor your accounting system already knows.

  • Jobs and tasks

    Read every job and its tasks. Create a job or a task and update its header.

    Carries: number, name, customer, status, branch, salesperson, currency, quoted value; for each task, its dates and what was quoted, planned and dispatched.

  • Purchase orders

    Send a purchase order to your accounting system for approval and get the result back.

    Carries: status, number, who approved it, what has been billed and paid.

  • Invoices

    Read invoices and write back payment status and your accounting system's record number.

A few practical questions

Before youask for access.

Access will be issued by Ribbiot, company by company.

Is the Ribbiot API live?

No. It is in build. The status address answers today, and no record can be read or written through the API yet.

When is the first release?

The first release is proposed for December 2026. Records arrive one at a time: people first, then customers and vendors, then jobs and tasks, purchase orders and invoices.

Who can use it?

Access will be issued by Ribbiot, company by company, for that company's own record. The API is built once for every customer, so connecting your company is setup work. There is no sign-up page and no key to generate yourself.

What can it read and write first?

People: list people, look one up, add, update, deactivate and bring back, so your roster stays in step with your payroll or human resources system. Customers and vendors follow, then jobs and tasks, purchase orders and invoices.

Do we need a developer?

Yes, on your team or at a partner you choose. Your system calls the API. Whoever runs that system maps Ribbiot's records to its own. For a connection Ribbiot sets up for you, see the integrations page.

All integrations
How do we ask?

Press the Ask for access button on this page. Tell us the system you want to connect, the records you need, and whether you need to read, write or both. We reply by email.

Remove the Fog of Operations

Bring one job.Get a clearer operating picture, from readiness to revenue.

Walk one job
API access request

Ask for access

Access will be issued by Ribbiot, company by company. Tell us the system you want to connect and the records you need. We reply by email with where your request stands.

Thanks. Your request for access is in, and we will reply by email.
That did not send. Email info@ribbiot.com and we will take it from there.