> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.datalbus.com.br/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.datalbus.com.br/_mcp/server.

# Score por motorista

GET https://datalbus.com.br:8000/api/v2/drivers/score

**Período:** de `dtIni` 00:00 até o fim de `dtFin`, no fuso horário da empresa. Período máximo padrão: 31 dias (pode variar conforme a configuração da empresa).

**Resposta 200** (paginada), com duas particularidades:

- `data` é um **objeto** cuja chave é o **nome do motorista**;
- a chave `events`, no nível raiz, lista os eventos considerados na pontuação (`id`, `event`, `enabled`).

Campos de cada item de `data`:

| Campo | Tipo | Nulo | Descrição |
| --- | --- | --- | --- |
| `geofence_names` | string | sim | Cercas onde os eventos ocorreram, separadas por vírgula |
| `curve` | integer | não | Curvas (esquerda + direita) |
| `speed_up` | string (numérico) | não | Excesso de velocidade: soma de ocorrências × duração (segundos) |
| `acceleration` | integer | não | Arrancadas bruscas |
| `braking` | integer | não | Frenagens bruscas |
| `total_score` | string (numérico) | não | Pontuação total: soma ponderada dos eventos listados em `events` |
| `abs` | integer | não | Acionamentos de ABS |
| `sharp_turn` | integer | não | Curvas bruscas (esquerda + direita) |
| `mkbe` | string (numérico) | não | Quilômetros médios entre eventos: `distance` / `total_score` |
| `distance` | string (numérico) | não | Distância percorrida no período (km) |
| `license_plate` | string | sim | Placa (para motorista: uma das placas dos veículos conduzidos) |
| `group_descr` | string | sim | Grupo do motorista (por motorista) ou do veículo (por veículo) |
| `line_name` | string | sim | Linhas operadas, separadas por vírgula (empresas com integração de linhas) |
| `worker_id` | integer | sim | Matrícula do motorista |
| `driver` | string | sim | Nome do motorista |

Somente eventos ocorridos com motorista identificado entram na pontuação.

**Erros:** `422` para datas ausentes, inválidas ou período acima do máximo.

Reference: https://docs.datalbus.com.br/datalbus-api-v-2/score-de-motoristas/score-por-motorista

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Query parameters

- `dtIni` (string, optional) — Obrigatório. Data inicial, formato `YYYY-MM-DD`.
- `dtFin` (string, optional) — Obrigatório. Data final (inclusiva), formato `YYYY-MM-DD`.
- `workerId[]` (integer, optional) — Matrículas dos motoristas (repita o parâmetro para vários valores).

## Response

### 200

OK

- `to` (integer, required)
- `data` (ScorePorMotoristaScoreDeMotoristasResponseData, required)
- `from` (integer, required)
- `path` (string, required)
- `links` (list of ScorePorMotoristaScoreDeMotoristasResponseLinksItem, required)
- `total` (integer, required)
- `events` (list of ScorePorMotoristaScoreDeMotoristasResponseEventsItem, required)
- `per_page` (integer, required)
- `last_page` (integer, required)
- `current_page` (integer, required)
- `last_page_url` (string, required)
- `first_page_url` (string, required)
- `next_page_url` (any, optional, nullable)
- `prev_page_url` (any, optional, nullable)

## Errors

### 401 Score Por Motorista Score De Motoristas Request Unauthorized Error

Unauthorized

- `message` (string, required)

### 422 Score Por Motorista Score De Motoristas Request Unprocessable Entity Error

Unprocessable Content

- `errors` (UnprocessableEntityErrorBodyErrors, required)
- `message` (string, required)

## Types

### ScorePorMotoristaScoreDeMotoristasResponseData

- `JOAO DA SILVA` (ScorePorMotoristaScoreDeMotoristasResponseDataJoaoDaSilva, required)

### ScorePorMotoristaScoreDeMotoristasResponseLinksItem

- `label` (string, required)
- `active` (boolean, required)
- `url` (any, optional, nullable)

### ScorePorMotoristaScoreDeMotoristasResponseEventsItem

- `id` (integer, required)
- `event` (string, required)
- `enabled` (boolean, required)

### UnprocessableEntityErrorBodyErrors

- `date` (list of string, required)
- `groupBy` (list of string, required)

### ScorePorMotoristaScoreDeMotoristasResponseDataJoaoDaSilva

- `abs` (integer, required)
- `mkbe` (string, required)
- `curve` (integer, required)
- `driver` (string, required)
- `braking` (integer, required)
- `distance` (string, required)
- `speed_up` (string, required)
- `line_name` (string, required)
- `worker_id` (integer, required)
- `sharp_turn` (integer, required)
- `group_descr` (string, required)
- `total_score` (string, required)
- `acceleration` (integer, required)
- `license_plate` (string, required)
- `geofence_names` (string, required)

## Examples

**Response**

```json
{
  "to": 1,
  "data": {
    "JOAO DA SILVA": {
      "abs": 0,
      "mkbe": "1.268",
      "curve": 12,
      "driver": "JOAO DA SILVA",
      "braking": 5,
      "distance": "459.12",
      "speed_up": "340",
      "line_name": "100 - Centro",
      "worker_id": 12345,
      "sharp_turn": 2,
      "group_descr": "MOTORISTA - GP1",
      "total_score": "362",
      "acceleration": 3,
      "license_plate": "ABC1D23",
      "geofence_names": "Garagem Norte, Terminal Central"
    }
  },
  "from": 1,
  "path": "https://datalbus.com.br:8000/api/v2/drivers/score",
  "links": [
    {
      "label": "« Previous",
      "active": false
    },
    {
      "label": "1",
      "active": true,
      "url": "https://datalbus.com.br:8000/api/v2/drivers/score?page=1"
    },
    {
      "label": "Next »",
      "active": false
    }
  ],
  "total": 1,
  "events": [
    {
      "id": 2,
      "event": "Excesso de velocidade",
      "enabled": true
    },
    {
      "id": 7,
      "event": "Arrancada brusca",
      "enabled": true
    },
    {
      "id": 15,
      "event": "Frenagem brusca",
      "enabled": true
    },
    {
      "id": 32,
      "event": "ABS",
      "enabled": true
    },
    {
      "id": 49,
      "event": "Curva à esquerda",
      "enabled": true
    },
    {
      "id": 50,
      "event": "Curva à direita",
      "enabled": true
    },
    {
      "id": 54,
      "event": "Curva brusca à direita",
      "enabled": true
    },
    {
      "id": 55,
      "event": "Curva brusca à esquerda",
      "enabled": true
    }
  ],
  "per_page": 10,
  "last_page": 1,
  "current_page": 1,
  "last_page_url": "https://datalbus.com.br:8000/api/v2/drivers/score?page=1",
  "first_page_url": "https://datalbus.com.br:8000/api/v2/drivers/score?page=1"
}
```

**SDK Code**

```python 200 - Score por motorista
import requests

url = "https://datalbus.com.br:8000/api/v2/drivers/score"

querystring = {"dtFin":"2026-10-07","dtIni":"2026-10-01"}

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

```javascript 200 - Score por motorista
const url = 'https://datalbus.com.br:8000/api/v2/drivers/score?dtFin=2026-10-07&dtIni=2026-10-01';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go 200 - Score por motorista
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://datalbus.com.br:8000/api/v2/drivers/score?dtFin=2026-10-07&dtIni=2026-10-01"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby 200 - Score por motorista
require 'uri'
require 'net/http'

url = URI("https://datalbus.com.br:8000/api/v2/drivers/score?dtFin=2026-10-07&dtIni=2026-10-01")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java 200 - Score por motorista
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://datalbus.com.br:8000/api/v2/drivers/score?dtFin=2026-10-07&dtIni=2026-10-01")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php 200 - Score por motorista
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://datalbus.com.br:8000/api/v2/drivers/score?dtFin=2026-10-07&dtIni=2026-10-01', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp 200 - Score por motorista
using RestSharp;

var client = new RestClient("https://datalbus.com.br:8000/api/v2/drivers/score?dtFin=2026-10-07&dtIni=2026-10-01");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift 200 - Score por motorista
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://datalbus.com.br:8000/api/v2/drivers/score?dtFin=2026-10-07&dtIni=2026-10-01")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```