> 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

GET https://api.taktoria.com/api/v1/organization

The workspace's settings, as Settings → Workspace shows them. Requires `organization:read`.

Reference: https://docs.taktoria.com/api-reference/organization/get

## 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)

## Response

### 200

- `id` (string, required)
- `name` (string, required)
- `slug` (string, required) — The workspace's address, as in `taktoria.com/app/{slug}`. Unique across Taktoria.
- `whitelabel` (boolean, required) — The workspace's own name and icon stand in for Taktoria's in the app.
- `fiscalYearStartMonth` (integer, required) — The calendar month (1 to 12) the fiscal year, and so Q1, starts in. Every app that talks in quarters reads it: OKR Hub's periods, and LaunchCal's "Launched this quarter".
- `okrYears` (list of integer, required) — The fiscal years OKR Hub offers in its period pickers and on the scorecard besides the current one, which it always offers. Newest first; empty for the current year alone.
- `holidayMarkets` (list of string, required) — The countries, as ISO codes (`US`, `GB`), whose public holidays LaunchCal shows on its calendar and warns about when a launch is planned on one. The United States until somebody picks; empty for none. See `GET /holidays`.
- `requireGoogleSignIn` (boolean, required) — Members must be signed in with Google to open the workspace. A session made any other way is refused by the API with `google_sign_in_required`; keys are unaffected. It also makes every go link and Dory event set to `DOMAIN` take Google's word alone, whatever its own `requireGoogle` says: their `requireGoogle` then reads true.
- `slackCommandsWithoutGoogle` (boolean, required) — **Allow Slack commands without Google sign-in**, under **Require sign-in with Google** in Settings → Workspace. Slack cannot sign in with Google, so while Google is required, Taktoria's Slack commands act only for somebody who has connected their Slack account by signing in with Google once (see `GET /slack-connections`). On, they take the address Slack has confirmed instead, as in a workspace that does not require Google. It means nothing while `requireGoogleSignIn` is false. Off by default.
- `googleSignInAvailable` (boolean, required) — Whether Google sign-in is set up on this installation, so it can be required.
- `autoGrowSeats` (boolean, required) — **Add seats as people join**, in Settings → Domains. While a verified domain has `autoJoin` on, somebody who joins gets their default seat on an app even when its seats are all taken, and the seats paid for rise by one (`seatsPaid` on the subscription; Stripe's quantity follows, prorated). Off, that app is skipped: the newcomer goes on its waiting list (`GET /seats/waiting`), and owners and admins are emailed who is waiting. It does nothing while no domain has `autoJoin` on. On by default.
- `allowCalendarFeeds` (boolean, required) — **Allow calendar feeds**, in Settings → Workspace: whether members may subscribe to LaunchCal from Google Calendar, Outlook or Apple Calendar. A feed is a private address read with no sign-in, around **Require Google sign-in** and single sign-on, so a workspace that holds every way in to those turns it off: every feed then answers 404 and none can be made, until it is on again. On by default. Feeds themselves have no API: each address is a person's secret.
- `logo` (string, optional) — The workspace icon's URL, when one has been uploaded.
- `defaultTimeZone` (string, optional) — The IANA zone picked to start with wherever a time zone is asked, such as a Dory event's, and what an event created through the API without one is given. Absent for none (UTC there).

## Errors

### 401 Unauthorized Error

- `error` (ErrorDetail, required)

### 403 Forbidden Error

Refused, and `error.code` says why. On an app's write endpoints, a signed-in session is refused `viewer_only` when the person is a Viewer of the app (they read it, and change nothing in it), and `seat_required` without a seat on it; a key is never either. Beyond those: `admin_required` when the change is an admin's (an app admin's for an app's admin powers, a workspace admin's for the workspace's settings), `forbidden` when the person may not change this one thing, `read_only_session` for a change only a key makes, `person_required` for what only a signed-in person does through their own account elsewhere (exporting a LaunchCal artifact to their docs tool), which a key cannot, `insufficient_scope` for a key without the scope, and `google_sign_in_required` for a session the workspace's Google rule turns away. Nothing was done.

- `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

### ErrorDetail

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

## Examples

**Response**

```json
{
  "id": "org_1",
  "name": "Acme",
  "slug": "acme",
  "whitelabel": false,
  "fiscalYearStartMonth": 4,
  "okrYears": [
    2025
  ],
  "holidayMarkets": [
    "US",
    "GB"
  ],
  "requireGoogleSignIn": false,
  "slackCommandsWithoutGoogle": false,
  "googleSignInAvailable": true,
  "autoGrowSeats": true,
  "allowCalendarFeeds": true,
  "logo": null,
  "defaultTimeZone": "Europe/Berlin"
}
```

**SDK Code**

```python
import requests

url = "https://api.taktoria.com/api/v1/organization"

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

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

print(response.json())
```

```javascript
const url = 'https://api.taktoria.com/api/v1/organization';
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/organization"

	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/organization")

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/organization")
  .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/organization', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.taktoria.com/api/v1/organization");
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/organization")! 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()
```