> 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. # Update PATCH https://api.taktoria.com/api/v1/organization Content-Type: application/json Rename the workspace, move its slug, set its fiscal year, the years OKR Hub offers, the default time zone, LaunchCal's holiday markets, whether seats grow as people join (`autoGrowSeats`), whether LaunchCal's calendar feeds are allowed (`allowCalendarFeeds`) or whether Slack commands take Slack's word while Google is required (`slackCommandsWithoutGoogle`). Requires `organization:write`, which a signed-in session never has: this takes a key. Everything is checked before anything is written. `requireGoogleSignIn` can be read but not changed here: it is turned on in Settings → Workspace, by a workspace admin signed in with Google, so nobody locks the workspace against the way they came in. Sending it is a `422 validation_error`. Errors: `409 slug_taken`, `422 validation_error`. Reference: https://docs.taktoria.com/api-reference/organization/update ## Authentication - `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer `, where token is your auth token. ## Servers - `https://api.taktoria.com/api/v1` (Production, default) - `http://localhost:3000/api/v1` (Local) ## Request ### Body (application/json) This endpoint expects an UpdateOrganizationRequest. - `name` (string, optional) — 1 to 100 characters. - `slug` (string, optional) — Turned into a slug the way the settings page does it: lowercased, every run of other characters made one hyphen, and cut at 48 characters. `Acme Corp` becomes `acme-corp`. - `fiscalYearStartMonth` (integer, optional) — 1 to 12. Objectives keep the year and quarter they were filed under; only the dates those cover move. LaunchCal's "this quarter" moves with it. - `okrYears` (list of integer, optional) — Replaces the years OKR Hub offers besides the current one: each 2000 to 2100. Empty or null for the current year alone. - `defaultTimeZone` (string, optional) — An IANA zone this server knows, or null for none. - `holidayMarkets` (list of string, optional) — Replaces LaunchCal's holiday markets: ISO country codes, at most 20. Empty for none, null for the default (the United States). A code no holidays are known for is a `422 validation_error` naming it. - `autoGrowSeats` (boolean, optional) — Whether a full app's seats grow for people who join while auto-join is on. Turned on, nobody waits: everybody on a waiting list is given a seat at once, and the seats paid for rise to fit them. Each change is in the audit log and the activity feed, as it is from Settings → Domains. - `allowCalendarFeeds` (boolean, optional) — Whether members may subscribe to LaunchCal from a calendar app. Turned off, every feed stops answering at once, and none is deleted: turned on again, they work as before. Each change is in the audit log, as it is from Settings → Workspace. - `slackCommandsWithoutGoogle` (boolean, optional) — Whether Taktoria's Slack commands take Slack's confirmed address while Google is required, rather than asking each person to connect with Google. Turned off, everybody who has not connected is asked to at their next command; connections already made keep working. Each change is in the audit log, as it is from Settings → Workspace. ## 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) ### 409 Conflict Error The request conflicts with how things stand, and `error.code` says how: `conflict` in general, or an endpoint's own code (`draft`, `launched`, `steps_incomplete`, `ticketing_not_connected`, `docs_not_connected`, …), listed in its description and under Errors and pagination. Nothing was done. - `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 ### ErrorDetail - `code` (string, required) — A stable machine-readable code such as `not_found`. - `message` (string, required) - `details` (any, optional) ## Examples **Request** ```json {} ``` **Response** ```json { "id": "id", "name": "name", "slug": "slug", "whitelabel": true, "fiscalYearStartMonth": 1, "okrYears": [ 1, 1 ], "holidayMarkets": [ "holidayMarkets", "holidayMarkets" ], "requireGoogleSignIn": true, "slackCommandsWithoutGoogle": true, "googleSignInAvailable": true, "autoGrowSeats": true, "allowCalendarFeeds": true, "logo": "logo", "defaultTimeZone": "defaultTimeZone" } ``` **SDK Code** ```python import requests url = "https://api.taktoria.com/api/v1/organization" payload = {} headers = { "Authorization": "Bearer ", "Content-Type": "application/json" } response = requests.patch(url, json=payload, headers=headers) print(response.json()) ``` ```javascript const url = 'https://api.taktoria.com/api/v1/organization'; const options = { method: 'PATCH', headers: {Authorization: 'Bearer ', 'Content-Type': 'application/json'}, body: '{}' }; 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" "strings" "net/http" "io" ) func main() { url := "https://api.taktoria.com/api/v1/organization" payload := strings.NewReader("{}") req, _ := http.NewRequest("PATCH", url, payload) req.Header.Add("Authorization", "Bearer ") req.Header.Add("Content-Type", "application/json") 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::Patch.new(url) request["Authorization"] = 'Bearer ' request["Content-Type"] = 'application/json' request.body = "{}" response = http.request(request) puts response.read_body ``` ```java import com.mashape.unirest.http.HttpResponse; import com.mashape.unirest.http.Unirest; HttpResponse response = Unirest.patch("https://api.taktoria.com/api/v1/organization") .header("Authorization", "Bearer ") .header("Content-Type", "application/json") .body("{}") .asString(); ``` ```php request('PATCH', 'https://api.taktoria.com/api/v1/organization', [ 'body' => '{}', 'headers' => [ 'Authorization' => 'Bearer ', 'Content-Type' => 'application/json', ], ]); echo $response->getBody(); ``` ```csharp using RestSharp; var client = new RestClient("https://api.taktoria.com/api/v1/organization"); var request = new RestRequest(Method.PATCH); request.AddHeader("Authorization", "Bearer "); request.AddHeader("Content-Type", "application/json"); request.AddParameter("application/json", "{}", ParameterType.RequestBody); IRestResponse response = client.Execute(request); ``` ```swift import Foundation let headers = [ "Authorization": "Bearer ", "Content-Type": "application/json" ] let parameters = [] as [String : Any] let postData = JSONSerialization.data(withJSONObject: parameters, options: []) let request = NSMutableURLRequest(url: NSURL(string: "https://api.taktoria.com/api/v1/organization")! as URL, cachePolicy: .useProtocolCachePolicy, timeoutInterval: 10.0) request.httpMethod = "PATCH" request.allHTTPHeaderFields = headers request.httpBody = postData as Data 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() ```