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

# Get Team Okrs

GET https://api.taktoria.com/api/v1/okrhub/teams/{teamSlug}

One team's page in OKR Hub, by its slug, for a fiscal period (the
current one unless given): who is on it, every objective it or a
team inside it owns, whole, and those it only holds a key result
of, with just those key results; the rollup; and what the caller
may do with each objective. Not paged. Needs `objectives:read`.

Reference: https://docs.taktoria.com/api-reference/okr/get-team-okrs

## Authentication

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

## Servers

- `https://api.taktoria.com/api/v1` (Production, default)
- `http://localhost:3000/api/v1` (Local)

## Request

### Path parameters

- `teamSlug` (string, required)

### Query parameters

- `year` (integer, optional) — The fiscal year; with `quarter`, that quarter; alone, the year.
- `quarter` (integer, optional)
- `period` (enum, optional)
  - Allowed values: `QUARTERLY`, `ANNUAL`

## Response

### 200

- `team` (TeamOkrsTeam, required)
- `period` (OkrPeriodRef, required) — A fiscal period of the workspace's own, which need not match the calendar's: its fiscal year starts in `fiscalYearStartMonth`, and is named by the year its Q1 falls in.
- `objectives` (list of ObjectiveDetail, required) — Every objective it or a team inside it owns, whole, and those it only holds a key result of, with just those key results and scored on them; in the workspace's order.
- `rollup` (OkrRollups, required) — The big score above a list in the app: every objective that matches (not only this page), each its key results' weighted mean, averaged by the objectives' weights. Unscored ones are left out, not counted as zero.
- `canAddObjective` (boolean, required) — Always `true`: anybody with a seat may add an objective for any team. A Viewer of OKR Hub may not, whatever this says (`403 viewer_only`).

## Errors

### 404 Not Found Error

- `error` (ErrorDetail, required)

### 402 Subscription Required Error

The organization has no subscription for the app that lets it in: active, trialing or past due. One that is unpaid (Stripe stopped retrying a failed payment), paused, incomplete or cancelled answers this too, and the message says which: an unpaid app is locked until a workspace admin updates the payment details. `details.status` is the app's subscription status (null with none), and `details.paymentIssue` is `unpaid`, or `payment_failed` for an incomplete one whose first payment failed, as `paymentIssue` on `GET /subscription` reckons it; null when a payment is not why.

- `error` (ErrorDetail, required)

### 422 Validation Error

- `error` (ErrorDetail, required)

### 429 Too Many Requests Error

Rate limited (`rate_limited`): the key, the signed-in person, the workspace or an expensive endpoint's own budget is used up for now. `Retry-After` says how many seconds to wait, and `details` names the `policy`, its `limit`, `windowSeconds` and `retryAfter`. Every answer to an authenticated request carries the IETF `RateLimit-Policy` and `RateLimit` headers, so a client can slow down before it gets this. Nothing was done; wait and send it again. See "Rate limits".

- `error` (ErrorDetail, required)

## Types

### TeamOkrsTeam

- `id` (string, required)
- `name` (string, required)
- `slug` (string, required)
- `subteams` (list of OkrTeamRef, required) — The teams directly inside it; their people are on it too.
- `people` (list of User, required) — The people on it directly.
- `description` (string, optional)

### OkrPeriodRef

A fiscal period of the workspace's own, which need not match the calendar's: its fiscal year starts in `fiscalYearStartMonth`, and is named by the year its Q1 falls in.

- `period` (enum, required)
  - Allowed values: `QUARTERLY`, `ANNUAL`
- `year` (integer, required)
- `label` (string, required) — As the app shows it, `FY2026 Q3`, or `FY2026` for a year.
- `quarter` (integer, optional) — 1 to 4 for a quarter; absent for a fiscal year.

### ObjectiveDetail

An objective, with what the caller may do with it.

- `archived` (boolean, required)
- `canEdit` (boolean, required) — Whether the caller may change it and its key results' definitions (add, edit, reorder, delete): its owner, its team (or a team inside it), whoever created it, or an app admin of OKR Hub. Always `true` for a key. It answers by those rules alone: a Viewer of OKR Hub changes nothing whatever it says (`403 viewer_only`).
- `createdAt` (datetime, required)
- `draft` (boolean, required) — Still being worked out, not yet agreed. A label only: a draft is seen, scored, rolled up and checked in on like any other.
- `id` (string, required)
- `keyResults` (list of KeyResult, required)
- `organizationId` (string, required)
- `period` (enum, required)
  - Allowed values: `QUARTERLY`, `ANNUAL`
- `sortOrder` (integer, required) — Its place in the workspace's order of objectives, which is set by hand and which every list follows within a period.
- `title` (string, required)
- `updatableKeyResultIds` (list of string, required) — The key results the caller may check in on and grade: all of them for anybody who may edit it, and their own (directly or through a team) for anybody else. Every one, for a key.
- `updatedAt` (datetime, required)
- `visibility` (enum, required) — Public objectives are browsable by everyone in the workspace. Private ones are visible to their owner, the members of the owning team, and whoever created them, whoever they belong to. The owners of its key results see it too.
  - Allowed values: `PUBLIC`, `PRIVATE`
- `weight` (double, required) — Relative weight when objectives roll up into an average, 0.01 to 100. One carrying twice the weight moves the average twice as much.
- `year` (integer, required) — The fiscal year, 2000 to 2100, named by the year its Q1 falls in.
- `description` (string, optional)
- `owner` (User, optional) — The person it belongs to. Absent, with `team`, for an objective with no owner.
- `ownerUserId` (string, optional)
- `quarter` (integer, optional) — 1-4 for a quarterly objective, absent for an annual one.
- `score` (double, optional) — The weighted average of its key results' grades, or absent when none has been scored. Absent rather than 0.0 on purpose: an unscored objective has not failed, and a zero would say it had.
- `team` (OrgTeamRef, optional) — The team it belongs to. Absent, with `owner`, for an objective with no owner.
- `teamId` (string, optional)

### OkrRollups

The big score above a list in the app: every objective that matches (not only this page), each its key results' weighted mean, averaged by the objectives' weights. Unscored ones are left out, not counted as zero.

- `overall` (OkrRollup, required)
- `byPriority` (map from enum to OkrRollup, required) — Each priority's average, every objective judged on its key results of that priority alone.

### ErrorDetail

- `code` (string, required) — A stable machine-readable code such as `not_found`.
- `message` (string, required)
- `details` (any, optional)

### OkrTeamRef

- `id` (string, required)
- `name` (string, required)
- `slug` (string, required)

### User

A person in a Taktoria organization.

- `id` (string, required)
- `name` (string, required)
- `email` (string, required)
- `image` (string, optional) — Their picture: one uploaded on the account page, or else their Google profile picture, brought in when they sign in with Google.

### KeyResult

A measurable result that grades its objective. It has its own weight, priority and owners, who need not be the objective's: the people and teams doing the work, who may check in on it and grade it.

- `id` (string, required)
- `objectiveId` (string, required)
- `title` (string, required)
- `weight` (double, required) — Relative weight within its own objective, 0.01 to 100.
- `priority` (enum, required) — A key result's priority, and the dimension scores are averaged by, so a workspace can see how it did on what mattered most rather than only in aggregate. Objectives have none: a priority's average takes each objective on its key results of that priority alone, with the objective's own weight.
  - Allowed values: `P0`, `P1`, `P2`, `P3`
- `draft` (boolean, required) — Still being worked out, not yet agreed. A label only: a draft is seen, scored, rolled up and checked in on like any other.
- `sortOrder` (integer, required) — Its place among its objective's key results, lowest first.
- `ownerUserIds` (list of string, required) — Members of the workspace who own it, directly.
- `ownerTeamIds` (list of string, required) — Teams of the workspace that own it; their members count as owners.
- `createdAt` (datetime, required)
- `updatedAt` (datetime, required)
- `score` (double, optional) — Google-style grade from 0.0 to 1.0, or absent until it has been scored. 0.7 and up is delivered for an ambitious goal, 0.4 to 0.7 is progress, and under 0.4 is missed. A **Final** grade set on the scorecard is the score. Until there is one, the score is the newest of the key result's other scorecard grades and its latest check-in. A score reset on the scorecard (`noScore`) empties that cell only and leaves this alone. It is what the dashboard's lists show, and what the objective's `score` rolls up.
- `lastCheckInAt` (datetime, optional) — When it was last checked in on: its newest check-in's `recordedAt`, so a check-in recorded late counts at its date. Absent if it has never been checked in on. How long it has gone quiet.
- `metric` (KeyResultMetric, optional) — The connected metric that drives its score, absent if none. Each number the metric hears becomes a check-in, and a person's own check-in stands only until the metric next moves. Sources are set up on the key result's page in the app, not through the API.

### OrgTeamRef

An organizational team such as Eagles or Ravens.

- `id` (string, required)
- `name` (string, required)

### OkrRollup

- `scored` (integer, required) — How many objectives carried a score.
- `total` (integer, required) — How many objectives there were.
- `score` (double, optional) — The weighted mean, 0 to 1, to two places; absent when nothing is scored.

### KeyResultMetric

The metric a key result follows, as anybody who may see the key result sees it. Never its secret, token or address.

- `name` (string, required) — What the number is, as the history names it, such as "Weekly active teams".
- `kind` (enum, required) — How a metric hears its number.
  - Allowed values: `WEBHOOK`, `PULL`
- `paused` (boolean, required) — Paused, it records nothing until somebody resumes it.

## Examples

**Response**

```json
{
  "team": {
    "id": "team_1",
    "name": "Platform",
    "slug": "platform",
    "subteams": [],
    "people": [
      {
        "id": "usr_1",
        "name": "Sam Lee",
        "email": "sam@example.com"
      }
    ]
  },
  "period": {
    "period": "QUARTERLY",
    "year": 2026,
    "label": "FY2026 Q3",
    "quarter": 3
  },
  "objectives": [],
  "rollup": {
    "overall": {
      "scored": 0,
      "total": 0
    },
    "byPriority": {
      "P0": {
        "scored": 0,
        "total": 0
      },
      "P1": {
        "scored": 0,
        "total": 0
      },
      "P2": {
        "scored": 0,
        "total": 0
      },
      "P3": {
        "scored": 0,
        "total": 0
      }
    }
  },
  "canAddObjective": true
}
```

**SDK Code**

```python
import requests

url = "https://api.taktoria.com/api/v1/okrhub/teams/platform"

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

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

print(response.json())
```

```javascript
const url = 'https://api.taktoria.com/api/v1/okrhub/teams/platform';
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
package main

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

func main() {

	url := "https://api.taktoria.com/api/v1/okrhub/teams/platform"

	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
require 'uri'
require 'net/http'

url = URI("https://api.taktoria.com/api/v1/okrhub/teams/platform")

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
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.taktoria.com/api/v1/okrhub/teams/platform")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.taktoria.com/api/v1/okrhub/teams/platform', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.taktoria.com/api/v1/okrhub/teams/platform");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.taktoria.com/api/v1/okrhub/teams/platform")! 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()
```