One read of Claude Developer Platformapi-20260828T173708Z
53 pages moved out of 688 read.
Pages moved
53
significant first
Pages read
688
in this capture
Captured
17:37 UTC
Corpus hash
ca2e3b841543
corpus-hash
What this read moved
26-50 of 53, page 2 of 3This capture is too large to show at once. Changes 26-50 of 53 are below, significant first; the rest are on the following screens.
api/beta/skills/versions/delete Changed · +12 / -12 lines
from line 14
1414
1515- `version: string`
1616
17 Version identifier for the skill.
17 Identifies the skill version by its version ID.
1818
19 Each version is identified by a Unix epoch timestamp (e.g., "1759178010641129").
19 Requests carrying the `skills-2025-10-02` beta header address versions by their Unix epoch timestamp instead (e.g., "1759178010641129").
2020
2121## Headers
2222
from line 112
112112
113113## Returns
114114
115- `id: string`
115- `BetaDeletedSkillVersion object`
116116
117 Version identifier for the skill.
117 - `id: string`
118118
119 Each version is identified by a Unix epoch timestamp (e.g., "1759178010641129").
119 Unique identifier for this Skill Version. The id addresses the version in
120 paths and pins it in references.
120121
121- `type: string`
122 - `type: "skill_version_deleted"`
122123
123 Deleted object type.
124 Deleted object type.
124125
125 For Skill Versions, this is always `"skill_version_deleted"`.
126 For Skill Versions, this is always `"skill_version_deleted"`.
126127
127 default: skill_version_deleted
128 default: skill_version_deleted
128129
129130## Example
130131
from line 133
132133curl https://api.anthropic.com/v1/skills/$SKILL_ID/versions/$VERSION \
133134 -X DELETE \
134135 -H 'anthropic-version: 2023-06-01' \
135 -H 'anthropic-beta: skills-2025-10-02' \
136136 -H "X-Api-Key: $ANTHROPIC_API_KEY"
137137```
138138
from line 140
140140
141141```json
142142{
143 "id": "1759178010641129",
144 "type": "type"
143 "id": "id",
144 "type": "skill_version_deleted"
145145}
146146```
147147
api/beta/skills/versions/download Changed · +2 / -3 lines
from line 14
1414
1515- `version: string`
1616
17 Version identifier for the skill.
17 Identifies the skill version by its version ID.
1818
19 Each version is identified by a Unix epoch timestamp (e.g., "1759178010641129").
19 Requests carrying the `skills-2025-10-02` beta header address versions by their Unix epoch timestamp instead (e.g., "1759178010641129").
2020
2121## Headers
2222
from line 115
115115```bash
116116curl https://api.anthropic.com/v1/skills/$SKILL_ID/versions/$VERSION/content \
117117 -H 'anthropic-version: 2023-06-01' \
118 -H 'anthropic-beta: skills-2025-10-02' \
119118 -H "X-Api-Key: $ANTHROPIC_API_KEY"
120119```
121120
api/beta/skills/versions/list Changed · +27 / -39 lines
from line 16
1616
1717- `limit: optional number`
1818
19 Number of items to return per page.
19 Number of results to return per page.
2020
21 Defaults to `20`. Ranges from `1` to `1000`.
21 Ranges from `1` to `1000`. Defaults to `20`.
2222
23 default: 20, minimum: 1, maximum: 1000
24
2325- `page: optional string`
2426
2527 Optionally set to the `next_page` token from the previous response.
from line 120
118120
119121## Returns
120122
121- `data: array of object`
123- `data: array of BetaSkillVersion`
122124
123 List of skill versions.
125 List of skills.
124126
125127 - `id: string`
126128
127 Unique identifier for the skill version.
129 Unique identifier for this Skill Version. The id addresses the version in
130 paths and pins it in references.
128131
129 The format and length of IDs may change over time.
130
131132 - `created_at: string`
132133
133 ISO 8601 timestamp of when the skill version was created.
134 ISO 8601 timestamp of when the skill was created.
134135
136 format: date-time
137
135138 - `description: string`
136139
137140 Description of the skill version.
from line 141
138141
139142 This is extracted from the SKILL.md file in the skill upload.
140143
141 - `directory: string`
142
143 Directory name of the skill version.
144
145 This is the top-level directory name that was extracted from the uploaded files.
146
147144 - `name: string`
148145
149 Human-readable name of the skill version.
146 The Skill's immutable kebab-case slug, set at creation from the first
147 upload's SKILL.md frontmatter `name` (or its enclosing directory). Every
148 later upload must resolve to the same value. Also the top-level directory
149 of the Skill's mounted files and the base name of a downloaded archive.
150150
151 This is extracted from the SKILL.md file in the skill upload.
152
153151 - `skill_id: string`
154152
155 Identifier for the skill that this version belongs to.
153 Unique identifier for the skill.
156154
157 - `type: string`
155 The format and length of IDs may change over time.
158156
157 - `type: "skill_version"`
158
159159 Object type.
160160
161161 For Skill Versions, this is always `"skill_version"`.
from line 162
162162
163163 default: skill_version
164164
165 - `version: string`
166
167 Version identifier for the skill.
168
169 Each version is identified by a Unix epoch timestamp (e.g., "1759178010641129").
170
171- `has_more: boolean`
172
173 Indicates if there are more results in the requested page direction.
174
175165- `next_page: string or null`
176166
177 Token to provide in as `page` in the subsequent request to retrieve the next page of data.
167 Token for fetching the next page of results.
178168
169 If `null`, there are no more results available. Pass this value to the `page` parameter in the next request to get the next page.
170
179171## Example
180172
181173```bash
182174curl https://api.anthropic.com/v1/skills/$SKILL_ID/versions \
183175 -H 'anthropic-version: 2023-06-01' \
184 -H 'anthropic-beta: skills-2025-10-02' \
185176 -H "X-Api-Key: $ANTHROPIC_API_KEY"
186177```
187178
from line 182
191182{
192183 "data": [
193184 {
194 "id": "skillver_01JAbcdefghijklmnopqrstuvw",
185 "id": "id",
195186 "created_at": "2024-10-30T23:58:27.427722Z",
196 "description": "A custom skill for doing something useful",
197 "directory": "my-skill",
198 "name": "my-skill",
187 "description": "description",
188 "name": "name",
199189 "skill_id": "skill_01JAbcdefghijklmnopqrstuvw",
200 "type": "type",
201 "version": "1759178010641129"
190 "type": "skill_version"
202191 }
203192 ],
204 "has_more": true,
205 "next_page": "page_MjAyNS0wNS0xNFQwMDowMDowMFo="
193 "next_page": "next_page"
206194}
207195```
208196
api/beta/skills/versions/retrieve Changed · +28 / -37 lines
from line 14
1414
1515- `version: string`
1616
17 Version identifier for the skill.
17 Identifies the skill version: a version ID, or the literal `latest` for the skill's most recent version.
1818
19 Each version is identified by a Unix epoch timestamp (e.g., "1759178010641129").
19 Requests carrying the `skills-2025-10-02` beta header address versions by their Unix epoch timestamp instead (e.g., "1759178010641129").
2020
2121## Headers
2222
from line 112
112112
113113## Returns
114114
115- `id: string`
115- `BetaSkillVersion object`
116116
117 Unique identifier for the skill version.
117 - `id: string`
118118
119 The format and length of IDs may change over time.
119 Unique identifier for this Skill Version. The id addresses the version in
120 paths and pins it in references.
120121
121- `created_at: string`
122 - `created_at: string`
122123
123 ISO 8601 timestamp of when the skill version was created.
124 ISO 8601 timestamp of when the skill was created.
124125
125- `description: string`
126 format: date-time
126127
127 Description of the skill version.
128 - `description: string`
128129
129 This is extracted from the SKILL.md file in the skill upload.
130 Description of the skill version.
130131
131- `directory: string`
132 This is extracted from the SKILL.md file in the skill upload.
132133
133 Directory name of the skill version.
134 - `name: string`
134135
135 This is the top-level directory name that was extracted from the uploaded files.
136 The Skill's immutable kebab-case slug, set at creation from the first
137 upload's SKILL.md frontmatter `name` (or its enclosing directory). Every
138 later upload must resolve to the same value. Also the top-level directory
139 of the Skill's mounted files and the base name of a downloaded archive.
136140
137- `name: string`
141 - `skill_id: string`
138142
139 Human-readable name of the skill version.
143 Unique identifier for the skill.
140144
141 This is extracted from the SKILL.md file in the skill upload.
145 The format and length of IDs may change over time.
142146
143- `skill_id: string`
147 - `type: "skill_version"`
144148
145 Identifier for the skill that this version belongs to.
149 Object type.
146150
147- `type: string`
151 For Skill Versions, this is always `"skill_version"`.
148152
149 Object type.
153 default: skill_version
150154
151 For Skill Versions, this is always `"skill_version"`.
152
153 default: skill_version
154
155- `version: string`
156
157 Version identifier for the skill.
158
159 Each version is identified by a Unix epoch timestamp (e.g., "1759178010641129").
160
161155## Example
162156
163157```bash
164158curl https://api.anthropic.com/v1/skills/$SKILL_ID/versions/$VERSION \
165159 -H 'anthropic-version: 2023-06-01' \
166 -H 'anthropic-beta: skills-2025-10-02' \
167160 -H "X-Api-Key: $ANTHROPIC_API_KEY"
168161```
169162
from line 164
171164
172165```json
173166{
174 "id": "skillver_01JAbcdefghijklmnopqrstuvw",
167 "id": "id",
175168 "created_at": "2024-10-30T23:58:27.427722Z",
176 "description": "A custom skill for doing something useful",
177 "directory": "my-skill",
178 "name": "my-skill",
169 "description": "description",
170 "name": "name",
179171 "skill_id": "skill_01JAbcdefghijklmnopqrstuvw",
180 "type": "type",
181 "version": "1759178010641129"
172 "type": "skill_version"
182173}
183174```
184175
api/beta/webhooks Changed · +9 / -576 lines
## Parse Unverified ### Unwrap Webhook Event
The two sides of this change are more than 400 edits apart, too far apart to line up, so this is the differ's own diff of it and the words inside a line are not marked.
from line 2
22
33## Unwrap
44
5Verifies the webhook signature from the `webhook-id`, `webhook-timestamp` and `webhook-signature`
6headers using your webhook signing key, then parses the payload into an event. Fails if the
7signature is missing or invalid.
8
9## Parse Unverified
10
11Parses a webhook payload into an event without verifying its signature. Prefer `unwrap()` unless
12you have already verified the signature yourself.
13
514## Domain types
615
716### Beta Webhook Agent Archived Event Data
from line 1792
17831792 - `type: "vault.deleted"`
17841793
17851794 - `workspace_id: string`
1786
1787### Unwrap Webhook Event
1788
1789- `UnwrapWebhookEvent object`
1790
1791 - `id: string`
1792
1793 Unique event identifier for idempotency.
1794
1795 - `created_at: string`
1796
1797 RFC 3339 timestamp when the event occurred.
1798
1799 format: date-time
1800
1801 - `data: BetaWebhookEventData`
1802
1803 - `BetaWebhookSessionCreatedEventData object`
1804
1805 - `id: string`
1806
1807 ID of the session that triggered the event.
1808
1809 - `organization_id: string`
1810
1811 - `type: "session.created"`
1812
1813 - `workspace_id: string`
1814
1815 - `BetaWebhookSessionPendingEventData object`
1816
1817 - `id: string`
1818
1819 ID of the session that triggered the event.
1820
1821 - `organization_id: string`
1822
1823 - `type: "session.pending"`
1824
1825 - `workspace_id: string`
1826
1827 - `BetaWebhookSessionRunningEventData object`
1828
1829 - `id: string`
1830
1831 ID of the session that triggered the event.
1832
1833 - `organization_id: string`
1834
1835 - `type: "session.running"`
1836
1837 - `workspace_id: string`
1838
1839 - `BetaWebhookSessionIdledEventData object`
1840
1841 - `id: string`
1842
1843 ID of the session that triggered the event.
1844
1845 - `organization_id: string`
1846
1847 - `type: "session.idled"`
1848
1849 - `workspace_id: string`
1850
1851 - `BetaWebhookSessionRequiresActionEventData object`
1852
1853 - `id: string`
1854
1855 ID of the session that triggered the event.
1856
1857 - `organization_id: string`
1858
1859 - `type: "session.requires_action"`
1860
1861 - `workspace_id: string`
1862
1863 - `BetaWebhookSessionArchivedEventData object`
1864
1865 - `id: string`
1866
1867 ID of the session that triggered the event.
1868
1869 - `organization_id: string`
1870
1871 - `type: "session.archived"`
1872
1873 - `workspace_id: string`
1874
1875 - `BetaWebhookSessionDeletedEventData object`
1876
1877 - `id: string`
1878
1879 ID of the session that triggered the event.
1880
1881 - `organization_id: string`
1882
1883 - `type: "session.deleted"`
1884
1885 - `workspace_id: string`
1886
1887 - `BetaWebhookSessionStatusRescheduledEventData object`
1888
1889 - `id: string`
1890
1891 ID of the session that triggered the event.
1892
1893 - `organization_id: string`
1894
1895 - `type: "session.status_rescheduled"`
1896
1897 - `workspace_id: string`
1898
1899 - `BetaWebhookSessionStatusRunStartedEventData object`
1900
1901 - `id: string`
1902
1903 ID of the session that triggered the event.
1904
1905 - `organization_id: string`
1906
1907 - `type: "session.status_run_started"`
1908
1909 - `workspace_id: string`
1910
1911 - `BetaWebhookSessionStatusIdledEventData object`
1912
1913 - `id: string`
1914
1915 ID of the session that triggered the event.
1916
1917 - `organization_id: string`
1918
1919 - `type: "session.status_idled"`
1920
1921 - `workspace_id: string`
1922
1923 - `BetaWebhookSessionStatusTerminatedEventData object`
1924
1925 - `id: string`
1926
1927 ID of the session that triggered the event.
1928
1929 - `organization_id: string`
1930
1931 - `type: "session.status_terminated"`
1932
1933 - `workspace_id: string`
1934
1935 - `BetaWebhookSessionThreadCreatedEventData object`
1936
1937 - `id: string`
1938
1939 ID of the session that triggered the event.
1940
1941 - `organization_id: string`
1942
1943 - `session_thread_id: string`
1944
1945 ID of the session thread this event refers to.
1946
1947 - `type: "session.thread_created"`
1948
1949 - `workspace_id: string`
1950
1951 - `BetaWebhookSessionThreadIdledEventData object`
1952
1953 - `id: string`
1954
1955 ID of the session that triggered the event.
1956
1957 - `organization_id: string`
1958
1959 - `session_thread_id: string`
1960
1961 ID of the session thread this event refers to.
1962
1963 - `type: "session.thread_idled"`
1964
1965 - `workspace_id: string`
1966
1967 - `BetaWebhookSessionThreadTerminatedEventData object`
1968
1969 - `id: string`
1970
1971 ID of the session that triggered the event.
1972
1973 - `organization_id: string`
1974
1975 - `session_thread_id: string`
1976
1977 ID of the session thread this event refers to.
1978
1979 - `type: "session.thread_terminated"`
1980
1981 - `workspace_id: string`
1982
1983 - `BetaWebhookSessionOutcomeEvaluationEndedEventData object`
1984
1985 - `id: string`
1986
1987 ID of the session that triggered the event.
1988
1989 - `organization_id: string`
1990
1991 - `type: "session.outcome_evaluation_ended"`
1992
1993 - `workspace_id: string`
1994
1995 - `BetaWebhookVaultCreatedEventData object`
1996
1997 - `id: string`
1998
1999 ID of the vault that triggered the event.
2000
2001 - `organization_id: string`
2002
2003 - `type: "vault.created"`
2004
2005 - `workspace_id: string`
2006
2007 - `BetaWebhookVaultArchivedEventData object`
2008
2009 - `id: string`
2010
2011 ID of the vault that triggered the event.
2012
2013 - `organization_id: string`
2014
2015 - `type: "vault.archived"`
2016
2017 - `workspace_id: string`
2018
2019 - `BetaWebhookVaultDeletedEventData object`
2020
2021 - `id: string`
2022
2023 ID of the vault that triggered the event.
2024
2025 - `organization_id: string`
2026
2027 - `type: "vault.deleted"`
2028
2029 - `workspace_id: string`
2030
2031 - `BetaWebhookVaultCredentialCreatedEventData object`
2032
2033 - `id: string`
2034
2035 ID of the vault credential that triggered the event.
2036
2037 - `organization_id: string`
2038
2039 - `type: "vault_credential.created"`
2040
2041 - `vault_id: string`
2042
2043 ID of the vault that owns this credential.
2044
2045 - `workspace_id: string`
2046
2047 - `BetaWebhookVaultCredentialArchivedEventData object`
2048
2049 - `id: string`
2050
2051 ID of the vault credential that triggered the event.
2052
2053 - `organization_id: string`
2054
2055 - `type: "vault_credential.archived"`
2056
2057 - `vault_id: string`
2058
2059 ID of the vault that owns this credential.
2060
2061 - `workspace_id: string`
2062
2063 - `BetaWebhookVaultCredentialDeletedEventData object`
2064
2065 - `id: string`
2066
2067 ID of the vault credential that triggered the event.
2068
2069 - `organization_id: string`
2070
2071 - `type: "vault_credential.deleted"`
2072
2073 - `vault_id: string`
2074
2075 ID of the vault that owns this credential.
2076
2077 - `workspace_id: string`
2078
2079 - `BetaWebhookVaultCredentialRefreshFailedEventData object`
2080
2081 - `id: string`
2082
2083 ID of the vault credential that triggered the event.
2084
2085 - `organization_id: string`
2086
2087 - `type: "vault_credential.refresh_failed"`
2088
2089 - `vault_id: string`
2090
2091 ID of the vault that owns this credential.
2092
2093 - `workspace_id: string`
2094
2095 - `BetaWebhookSessionUpdatedEventData object`
2096
2097 - `id: string`
2098
2099 ID of the session that triggered the event.
2100
2101 - `organization_id: string`
2102
2103 - `type: "session.updated"`
2104
2105 - `workspace_id: string`
2106
2107 - `BetaWebhookAgentCreatedEventData object`
2108
2109 - `id: string`
2110
2111 ID of the agent that triggered the event.
2112
2113 - `organization_id: string`
2114
2115 - `type: "agent.created"`
2116
2117 - `workspace_id: string`
2118
2119 - `BetaWebhookAgentArchivedEventData object`
2120
2121 - `id: string`
2122
2123 ID of the agent that triggered the event.
2124
2125 - `organization_id: string`
2126
2127 - `type: "agent.archived"`
2128
2129 - `workspace_id: string`
2130
2131 - `BetaWebhookAgentDeletedEventData object`
2132
2133 - `id: string`
2134
2135 ID of the agent that triggered the event.
2136
2137 - `organization_id: string`
2138
2139 - `type: "agent.deleted"`
2140
2141 - `workspace_id: string`
2142
2143 - `BetaWebhookDeploymentPausedEventData object`
2144
2145 - `id: string`
2146
2147 ID of the deployment that triggered the event.
2148
2149 - `organization_id: string`
2150
2151 - `type: "deployment.paused"`
2152
2153 - `workspace_id: string`
2154
2155 - `BetaWebhookDeploymentRunFailedEventData object`
2156
2157 - `id: string`
2158
2159 ID of the deployment run that triggered the event.
2160
2161 - `organization_id: string`
2162
2163 - `type: "deployment_run.failed"`
2164
2165 - `workspace_id: string`
2166
2167 - `BetaWebhookDeploymentCreatedEventData object`
2168
2169 - `id: string`
2170
2171 ID of the deployment that triggered the event.
2172
2173 - `organization_id: string`
2174
2175 - `type: "deployment.created"`
2176
2177 - `workspace_id: string`
2178
2179 - `BetaWebhookDeploymentUpdatedEventData object`
2180
2181 - `id: string`
2182
2183 ID of the deployment that triggered the event.
2184
2185 - `organization_id: string`
2186
2187 - `type: "deployment.updated"`
2188
2189 - `workspace_id: string`
2190
2191 - `BetaWebhookDeploymentUnpausedEventData object`
2192
2193 - `id: string`
2194
2195 ID of the deployment that triggered the event.
2196
2197 - `organization_id: string`
2198
2199 - `type: "deployment.unpaused"`
2200
2201 - `workspace_id: string`
2202
2203 - `BetaWebhookAgentUpdatedEventData object`
2204
2205 - `id: string`
2206
2207 ID of the agent that triggered the event.
2208
2209 - `organization_id: string`
2210
2211 - `type: "agent.updated"`
2212
2213 - `workspace_id: string`
2214
2215 - `BetaWebhookDeploymentArchivedEventData object`
2216
2217 - `id: string`
2218
2219 ID of the deployment that triggered the event.
2220
2221 - `organization_id: string`
2222
2223 - `type: "deployment.archived"`
2224
2225 - `workspace_id: string`
2226
2227 - `BetaWebhookDeploymentRunStartedEventData object`
2228
2229 - `id: string`
2230
2231 ID of the deployment run that triggered the event.
2232
2233 - `organization_id: string`
2234
2235 - `type: "deployment_run.started"`
2236
2237 - `workspace_id: string`
2238
2239 - `BetaWebhookDeploymentDeletedEventData object`
2240
2241 - `id: string`
2242
2243 ID of the deployment that triggered the event.
2244
2245 - `organization_id: string`
2246
2247 - `type: "deployment.deleted"`
2248
2249 - `workspace_id: string`
2250
2251 - `BetaWebhookDeploymentRunSucceededEventData object`
2252
2253 - `id: string`
2254
2255 ID of the deployment run that triggered the event.
2256
2257 - `organization_id: string`
2258
2259 - `type: "deployment_run.succeeded"`
2260
2261 - `workspace_id: string`
2262
2263 - `BetaWebhookEnvironmentCreatedEventData object`
2264
2265 - `id: string`
2266
2267 ID of the environment that triggered the event.
2268
2269 - `organization_id: string`
2270
2271 - `type: "environment.created"`
2272
2273 - `workspace_id: string`
2274
2275 - `BetaWebhookEnvironmentUpdatedEventData object`
2276
2277 - `id: string`
2278
2279 ID of the environment that triggered the event.
2280
2281 - `organization_id: string`
2282
2283 - `type: "environment.updated"`
2284
2285 - `workspace_id: string`
2286
2287 - `BetaWebhookEnvironmentArchivedEventData object`
2288
2289 - `id: string`
2290
2291 ID of the environment that triggered the event.
2292
2293 - `organization_id: string`
2294
2295 - `type: "environment.archived"`
2296
2297 - `workspace_id: string`
2298
2299 - `BetaWebhookEnvironmentDeletedEventData object`
2300
2301 - `id: string`
2302
2303 ID of the environment that triggered the event.
2304
2305 - `organization_id: string`
2306
2307 - `type: "environment.deleted"`
2308
2309 - `workspace_id: string`
2310
2311 - `BetaWebhookMemoryStoreCreatedEventData object`
2312
2313 - `id: string`
2314
2315 ID of the memory store that triggered the event.
2316
2317 - `organization_id: string`
2318
2319 - `type: "memory_store.created"`
2320
2321 - `workspace_id: string`
2322
2323 - `BetaWebhookMemoryStoreArchivedEventData object`
2324
2325 - `id: string`
2326
2327 ID of the memory store that triggered the event.
2328
2329 - `organization_id: string`
2330
2331 - `type: "memory_store.archived"`
2332
2333 - `workspace_id: string`
2334
2335 - `BetaWebhookMemoryStoreDeletedEventData object`
2336
2337 - `id: string`
2338
2339 ID of the memory store that triggered the event.
2340
2341 - `organization_id: string`
2342
2343 - `type: "memory_store.deleted"`
2344
2345 - `workspace_id: string`
2346
2347 - `BetaWebhookSessionBudgetReachedEventData object`
2348
2349 - `id: string`
2350
2351 ID of the session that triggered the event.
2352
2353 - `organization_id: string`
2354
2355 - `type: "session.budget_reached"`
2356
2357 - `workspace_id: string`
2358
2359 - `type: "event"`
2360
2361 Object type. Always `event` for webhook payloads.
23621795
api/compliance/apps/projects Changed · +26 / -26 lines
from line 360
360360
361361## Domain types
362362
363### Project List Response
363### Project Retrieve Response
364364
365- `ProjectListResponse object`
365- `ProjectRetrieveResponse object`
366366
367 Project information for compliance responses.
367 Detailed project information for compliance responses.
368368
369369 - `id: string`
370370
371371 Project identifier (tagged ID)
372372
373 - `attachments_count: number`
374
375 Number of attachments contained within this project
376
377 - `chats_count: number`
378
379 Number of chats contained within this project
380
373381 - `created_at: string`
374382
375383 Project creation timestamp
from line 390
382390
383391 format: date-time
384392
393 - `description: string`
394
395 Project description
396
397 - `instructions: string`
398
399 Project's custom instructions / prompt
400
385401 - `is_private: boolean`
386402
387403 If false, the project is visible to all organization members; if true the project is accessible only to the creator and specified collaborators
from line 438
422438
423439 Organization identifier (tagged ID)
424440
425### Project Retrieve Response
441### Project List Response
426442
427- `ProjectRetrieveResponse object`
443- `ProjectListResponse object`
428444
429 Detailed project information for compliance responses.
445 Project information for compliance responses.
430446
431447 - `id: string`
432448
433449 Project identifier (tagged ID)
434450
435 - `attachments_count: number`
436
437 Number of attachments contained within this project
438
439 - `chats_count: number`
440
441 Number of chats contained within this project
442
443451 - `created_at: string`
444452
445453 Project creation timestamp
from line 459
451459 Timestamp when the project was deleted by an end user, or null otherwise
452460
453461 format: date-time
454
455 - `description: string`
456
457 Project description
458
459 - `instructions: string`
460
461 Project's custom instructions / prompt
462462
463463 - `is_private: boolean`
464464
api/compliance/apps/projects/documents Changed · +16 / -16 lines
from line 259
259259
260260 User's email address
261261
262### Document Delete Response
263
264- `DocumentDeleteResponse object`
265
266 Response for deleting a project document.
267
268 - `id: string`
269
270 The ID of the project document that was deleted
271
272 - `type: "claude_project_document_deleted"`
273
274 Constant string confirming deletion.
275
276 default: claude_project_document_deleted
277
262278### Document Metadata Response
263279
264280- `DocumentMetadataResponse object`
from line 331
315331 - `email_address: string`
316332
317333 User's email address
318
319### Document Delete Response
320
321- `DocumentDeleteResponse object`
322
323 Response for deleting a project document.
324
325 - `id: string`
326
327 The ID of the project document that was deleted
328
329 - `type: "claude_project_document_deleted"`
330
331 Constant string confirming deletion.
332
333 default: claude_project_document_deleted
334334
api/compliance/apps/sessions/local Changed · +6 / -6 lines
from line 222
222222
223223## Domain types
224224
225### Local List Response
225### Local Retrieve Response
226226
227- `LocalListResponse object`
227- `LocalRetrieveResponse object`
228228
229229 A session that a user ran on their own computer in a Claude app while
230230 signed in with their organization account.
from line 273
273273
274274 Workspace identifier (tagged ID, prefixed `wrkspc_`). Null for sessions not attributed to a workspace.
275275
276### Local Retrieve Response
276### Local List Response
277277
278- `LocalRetrieveResponse object`
278- `LocalListResponse object`
279279
280280 A session that a user ran on their own computer in a Claude app while
281281 signed in with their organization account.
api/compliance/groups Changed · +34 / -34 lines
from line 172
172172
173173## Domain types
174174
175### Group List Response
175### Group Retrieve Response
176176
177- `GroupListResponse object`
177- `GroupRetrieveResponse object`
178178
179179 Group information for compliance responses.
180180
from line 206
206206
207207 Group last-updated timestamp (ISO 8601)
208208
209### Group Retrieve Response
209### Group List Response
210210
211- `GroupRetrieveResponse object`
211- `GroupListResponse object`
212212
213213 Group information for compliance responses.
214214
api/compliance/organizations/roles Changed · +26 / -26 lines
from line 150
150150
151151## Domain types
152152
153### Role List Response
153### Role Retrieve Response
154154
155- `RoleListResponse object`
155- `RoleRetrieveResponse object`
156156
157157 Role information for compliance responses.
158158
from line 176
176176
177177 Role last-updated timestamp (ISO 8601)
178178
179### Role Retrieve Response
179### Role List Response
180180
181- `RoleRetrieveResponse object`
181- `RoleListResponse object`
182182
183183 Role information for compliance responses.
184184
build-with-claude/files Changed · +23 / -0 lines
## Migrate from `files-api-2025-04-14` ### SDK beta namespace
from line 977
977977
978978If your organization has the [Compliance API](https://platform.claude.com/docs/en/manage-claude/compliance-api) enabled, its [Activity Feed](https://platform.claude.com/docs/en/manage-claude/compliance-activity-feed) records Files API operations made with a Claude API key or from the Claude Console: each upload (`POST /v1/files`), content download (`GET /v1/files/{file_id}/content`), and deletion (`DELETE /v1/files/{file_id}`) appears as a `platform_file_uploaded`, `platform_file_content_downloaded`, or `platform_file_deleted` activity. Listing files and retrieving file metadata are not recorded. Operations that occur while the Compliance API is off are not recorded and cannot be recovered later, so [set up the Compliance API](https://platform.claude.com/docs/en/manage-claude/compliance-api-access) before you rely on this audit trail. On [Claude Platform on AWS](https://platform.claude.com/docs/en/build-with-claude/claude-platform-on-aws#monitoring-and-logging), audit file operations with AWS CloudTrail data events instead.
979979
980## Migrate from `files-api-2025-04-14`
981
982The Files API is out of beta and needs no beta header. Migrating off `files-api-2025-04-14` is optional: requests that still send it keep working and keep returning the beta response shapes, so an existing integration keeps working until you change it. Removing the header switches those requests to the shapes documented on this page:
983
984| | With `files-api-2025-04-14` | Without the header |
985| ---------------------------------------- | --------------------------------------- | ---------------------------------------------------------------------------- |
986| List response | `{ data, has_more, first_id, last_id }` | `{ data, next_page }`; pass `next_page` back as the `page` query parameter |
987| List cursors | `before_id`, `after_id` | `page`, or up to 100 `ids[]` (`before_id` and `after_id` return a 400 error) |
988| `expires_at` on file objects | Not returned | Always present; `null` when the file has no expiration |
989| `Content-Type` on the uploaded file part | Required | Optional; the type is detected when omitted |
990
991To migrate:
992
9931. **Remove the beta header.** Drop `anthropic-beta: files-api-2025-04-14` from your requests. In the SDKs, call `client.files` instead of `client.beta.files`; keeping `client.beta.files` works only on the [SDK releases that no longer send the header](https://platform.claude.com/docs/en/build-with-claude/files#sdk-beta-namespace). Earlier releases send it from `client.beta.files` even with no `betas` argument.
9942. **Update pagination.** Replace `after_id`/`before_id` loops with the `page`/`next_page` cursor, or use the SDK auto-pagination helpers shown in [Managing files](https://platform.claude.com/docs/en/build-with-claude/files#managing-files).
9953. **Read `expires_at`.** The field appears only without the header; `null` means the file has no expiration (see [File expiration](https://platform.claude.com/docs/en/build-with-claude/files#file-expiration)).
996
997### SDK beta namespace
998
999Starting with Python SDK 1.2.0, TypeScript SDK 0.122.0, Go SDK 1.68.0, Java SDK 2.59.0, Ruby SDK 1.67.0, and C# SDK 12.44.0, `client.beta.files` no longer sends `files-api-2025-04-14` and returns the same shapes as `client.files`, with `Beta`-prefixed type names. It accepts a `betas` argument for Files features that are still in beta, such as `scope_id` filtering under a [Managed Agents](https://platform.claude.com/docs/en/managed-agents/files) beta header. Earlier SDK releases are typed to the beta shapes; if you depend on those types, stay on an earlier release until you migrate.
1000
1001Requests that carry `anthropic-beta: managed-agents-2026-04-01` without `files-api-2025-04-14` receive the shapes on this page with one compatibility affordance on `GET /v1/files`: `before_id` and `after_id` are still accepted (not combinable with `page` or `ids[]`), and the list response includes `has_more`, `first_id`, and `last_id` alongside `next_page`. Later Managed Agents beta versions receive the plain shape.
1002
9801003## Error handling
9811004
9821005Common errors when using the Files API include:
build-with-claude/skills-guide Changed · +35 / -0 lines
## Migrate from `skills-2025-10-02` ### SDK beta namespace
from line 4653
46534653
46544654***
46554655
4656## Migrate from `skills-2025-10-02`
4657
4658The Skills API is out of beta and needs no beta header. Migrating off `skills-2025-10-02` is optional: requests that still send it keep working and keep returning the beta response shapes, so an existing integration keeps working until you change it. Removing the header switches those requests to the shapes documented on this page:
4659
4660| | With `skills-2025-10-02` | Without the header |
4661| ------------------------------- | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
4662| Skill label | `display_title` (up to 64 characters, unique per workspace) | `display_name` (up to 255 characters, not unique); derived from the `SKILL.md` `name` when omitted |
4663| Newest version pointer | `latest_version`, an epoch-microsecond string such as `"1759178010641129"` | `latest_version_id`, a version ID such as `"skver_01AbCdEfGhIjKlMnOpQrStUv"`; `GET /v1/skills/{skill_id}/versions/latest` resolves it in one call |
4664| Version identifier in URLs | Epoch-microsecond string | Version ID (`skver_...`). IDs captured under the beta with the `skill_version_` prefix are accepted as input. |
4665| Version object | Includes `directory` (always equal to the Skill `name`) | No `directory` field |
4666| `source` | A string, `"custom"` or `"anthropic"` | An object, for example `{"type": "custom"}`; the example catalog value is `"anthropic_example"` |
4667| List responses | `{ data, has_more, next_page }` | `{ data, next_page }`; `limit` from 1 to 1,000 (default 20) |
4668| Versions list order | Oldest first | Newest first, default `limit` 20. Page cursors from one shape are not valid on the other. |
4669| Deleting a Skill | Returns a 400 error while any version exists | Deletes the Skill and all of its versions |
4670| Deleting a Skill's only version | Allowed, leaving a Skill with no versions | Returns a 400 error; upload a replacement version first, or delete the Skill |
4671| Upload layout | Files must sit inside a top-level directory whose name matches the Skill `name` | `SKILL.md` may sit at the root of the upload; stored paths are the same either way |
4672| Response types | `CreateSkillResponse`, `GetSkillResponse`, and one type per operation | `Skill`, `SkillVersion`, `DeletedSkill`, `DeletedSkillVersion` |
4673
4674To migrate:
4675
46761. **Remove the beta header.** Drop `anthropic-beta: skills-2025-10-02` from your requests. In the SDKs, call `client.skills` instead of `client.beta.skills`; keeping `client.beta.skills` works only on the [SDK releases that no longer send the header](https://platform.claude.com/docs/en/build-with-claude/skills-guide#sdk-beta-namespace). Earlier releases send it from `client.beta.skills` even with no `betas` argument.
46772. **Rename fields** in your code: `display_title` to `display_name`, `latest_version` to `latest_version_id`, and read `source.type` instead of comparing `source` to a string.
46783. **Use version IDs.** Wherever you stored an epoch-microsecond version, store the version's `id` instead, or use `latest`. Skill references in Messages requests accept a version ID, `latest`, or (for Anthropic Skills) the catalog version.
46794. **Review delete calls.** `DELETE /v1/skills/{skill_id}` now removes every version with the Skill. If you relied on the beta's refusal as a safeguard, add your own check.
4680
4681<Warning>
4682 After migrating, `client.skills.delete(skill_id)` and `client.beta.skills.delete(skill_id)` delete the Skill together with all of its versions in one call.
4683</Warning>
4684
4685A Skill whose versions were all deleted under the beta has no current version to return: `GET /v1/skills/{skill_id}` returns a 400 error and the Skill is omitted from list responses until you upload a version to it. You can still delete it.
4686
4687### SDK beta namespace
4688
4689Starting with Python SDK 1.2.0, TypeScript SDK 0.122.0, Go SDK 1.68.0, Java SDK 2.59.0, Ruby SDK 1.67.0, and C# SDK 12.44.0, `client.beta.skills` no longer sends `skills-2025-10-02` and returns the same shapes as `client.skills`, with `Beta`-prefixed type names (`BetaSkill`, `BetaSkillVersion`, `BetaDeletedSkill`, `BetaDeletedSkillVersion`). It accepts a `betas` argument for Skills features that are still in beta. In the beta Messages types, the container Skill reference type is renamed from `BetaSkill` to `BetaContainerSkill` (same fields: `type`, `skill_id`, `version`); `BetaSkill` now names the Skill resource, matching `Skill` and `ContainerSkill` in the non-beta types. Earlier SDK releases are typed to the beta shapes; if you depend on those types, stay on an earlier release until you migrate.
4690
46564691## Data retention
46574692
46584693Agent Skills are not covered by ZDR arrangements. Skill definitions and execution data are retained according to Anthropic's standard data retention policy.
build-with-claude/structured-outputs Changed · +4 / -4 lines
from line 1406
14061406 -H "x-api-key: $ANTHROPIC_API_KEY" \
14071407 -H "anthropic-version: 2023-06-01" \
14081408 -d '{
1409 "model": "claude-opus-4-8",
1409 "model": "claude-opus-5",
14101410 "max_tokens": 4096,
14111411 "messages": [
14121412 {
from line 1740
17401740 -H "x-api-key: $ANTHROPIC_API_KEY" \
17411741 -H "anthropic-version: 2023-06-01" \
17421742 -d '{
1743 "model": "claude-opus-4-8",
1743 "model": "claude-opus-5",
17441744 "max_tokens": 1024,
17451745 "messages": [
17461746 {
from line 2027
20272027 -H "x-api-key: $ANTHROPIC_API_KEY" \
20282028 -H "anthropic-version: 2023-06-01" \
20292029 -d '{
2030 "model": "claude-opus-4-8",
2030 "model": "claude-opus-5",
20312031 "max_tokens": 1024,
20322032 "messages": [
20332033 {
from line 2379
23792379 -H "x-api-key: $ANTHROPIC_API_KEY" \
23802380 -H "anthropic-version: 2023-06-01" \
23812381 -d '{
2382 "model": "claude-opus-4-8",
2382 "model": "claude-opus-5",
23832383 "max_tokens": 1024,
23842384 "messages": [
23852385 {
build-with-claude/thinking-steering-and-cost Changed · +22 / -22 lines
from line 57
5757
5858```json
5959{
60 "model": "claude-opus-4-8",
60 "model": "claude-opus-5",
6161 "max_tokens": 4096,
6262 "output_config": { "effort": "medium" },
6363 "messages": [{ "role": "user", "content": "..." }]
from line 173
173173 # First request - establish cache
174174 print("First request - establishing cache")
175175 response1 = client.messages.create(
176 model="claude-opus-4-8",
176 model="claude-opus-5",
177177 max_tokens=16000,
178178 thinking={"type": "adaptive"},
179179 messages=MESSAGES,
from line 187
187187 # Second request - same configuration (cache hit expected)
188188 print("\nSecond request - same configuration (cache hit expected)")
189189 response2 = client.messages.create(
190 model="claude-opus-4-8",
190 model="claude-opus-5",
191191 max_tokens=16000,
192192 thinking={"type": "adaptive"},
193193 messages=MESSAGES,
from line 201
201201 # Third request - different effort level (cache miss expected)
202202 print("\nThird request - different effort level (cache miss expected)")
203203 response3 = client.messages.create(
204 model="claude-opus-4-8",
204 model="claude-opus-5",
205205 max_tokens=16000,
206206 thinking={"type": "adaptive"},
207207 output_config={"effort": "medium"},
from line 249
249249 // First request - establish cache
250250 console.log("First request - establishing cache");
251251 const response1 = await client.messages.create({
252 model: "claude-opus-4-8",
252 model: "claude-opus-5",
253253 max_tokens: 16000,
254254 thinking: { type: "adaptive" },
255255 messages
from line 265
265265 // Second request - same configuration (cache hit expected)
266266 console.log("\nSecond request - same configuration (cache hit expected)");
267267 const response2 = await client.messages.create({
268 model: "claude-opus-4-8",
268 model: "claude-opus-5",
269269 max_tokens: 16000,
270270 thinking: { type: "adaptive" },
271271 messages
from line 281
281281 // Third request - different effort level (cache miss expected)
282282 console.log("\nThird request - different effort level (cache miss expected)");
283283 const response3 = await client.messages.create({
284 model: "claude-opus-4-8",
284 model: "claude-opus-5",
285285 max_tokens: 16000,
286286 thinking: { type: "adaptive" },
287287 output_config: { effort: "medium" },
from line 303
303303 Console.WriteLine("First request - establishing cache");
304304 var parameters1 = new MessageCreateParams
305305 {
306 Model = Model.ClaudeOpus4_8,
306 Model = Model.ClaudeOpus5,
307307 MaxTokens = 16000,
308308 Thinking = new ThinkingConfigAdaptive(),
309309 Messages =
from line 333
333333 Console.WriteLine("\nSecond request - same configuration (cache hit expected)");
334334 var parameters2 = new MessageCreateParams
335335 {
336 Model = Model.ClaudeOpus4_8,
336 Model = Model.ClaudeOpus5,
337337 MaxTokens = 16000,
338338 Thinking = new ThinkingConfigAdaptive(),
339339 Messages =
from line 373
373373 Console.WriteLine("\nThird request - different effort level (cache miss expected)");
374374 var parameters3 = new MessageCreateParams
375375 {
376 Model = Model.ClaudeOpus4_8,
376 Model = Model.ClaudeOpus5,
377377 MaxTokens = 16000,
378378 Thinking = new ThinkingConfigAdaptive(),
379379 OutputConfig = new OutputConfig
from line 462
462462 // First request - establish cache
463463 fmt.Println("First request - establishing cache")
464464 response1, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
465 Model: anthropic.ModelClaudeOpus4_8,
465 Model: anthropic.ModelClaudeOpus5,
466466 MaxTokens: 16000,
467467 Thinking: anthropic.ThinkingConfigParamUnion{
468468 OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{},
from line 480
480480 // Second request - same configuration (cache hit expected)
481481 fmt.Println("\nSecond request - same configuration (cache hit expected)")
482482 response2, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
483 Model: anthropic.ModelClaudeOpus4_8,
483 Model: anthropic.ModelClaudeOpus5,
484484 MaxTokens: 16000,
485485 Thinking: anthropic.ThinkingConfigParamUnion{
486486 OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{},
from line 498
498498 // Third request - different effort level (cache miss expected)
499499 fmt.Println("\nThird request - different effort level (cache miss expected)")
500500 response3, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
501 Model: anthropic.ModelClaudeOpus4_8,
501 Model: anthropic.ModelClaudeOpus5,
502502 MaxTokens: 16000,
503503 Thinking: anthropic.ThinkingConfigParamUnion{
504504 OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{},
from line 529
529529 // First request - establishing cache
530530 IO.println("First request - establishing cache");
531531 MessageCreateParams params1 = MessageCreateParams.builder()
532 .model(Model.CLAUDE_OPUS_4_8)
532 .model(Model.CLAUDE_OPUS_5)
533533 .maxTokens(16000L)
534534 .thinking(ThinkingConfigAdaptive.builder().build())
535535 .addUserMessageOfBlockParams(List.of(
from line 549
549549 // Second request - same configuration (cache hit expected)
550550 IO.println("\nSecond request - same configuration (cache hit expected)");
551551 MessageCreateParams params2 = MessageCreateParams.builder()
552 .model(Model.CLAUDE_OPUS_4_8)
552 .model(Model.CLAUDE_OPUS_5)
553553 .maxTokens(16000L)
554554 .thinking(ThinkingConfigAdaptive.builder().build())
555555 .addUserMessageOfBlockParams(List.of(
from line 573
573573 // Third request - different effort level (cache miss expected)
574574 IO.println("\nThird request - different effort level (cache miss expected)");
575575 MessageCreateParams params3 = MessageCreateParams.builder()
576 .model(Model.CLAUDE_OPUS_4_8)
576 .model(Model.CLAUDE_OPUS_5)
577577 .maxTokens(16000L)
578578 .thinking(ThinkingConfigAdaptive.builder().build())
579579 .outputConfig(OutputConfig.builder()
from line 645
645645 ]
646646 ]
647647 ]],
648 model: 'claude-opus-4-8',
648 model: 'claude-opus-5',
649649 thinking: ['type' => 'adaptive'],
650650 );
651651
from line 678
678678 'content' => 'Analyze the characters in this passage.'
679679 ]
680680 ],
681 model: 'claude-opus-4-8',
681 model: 'claude-opus-5',
682682 thinking: ['type' => 'adaptive'],
683683 );
684684
from line 719
719719 'content' => 'Analyze the setting in this passage.'
720720 ]
721721 ],
722 model: 'claude-opus-4-8',
722 model: 'claude-opus-5',
723723 thinking: ['type' => 'adaptive'],
724724 outputConfig: ['effort' => 'medium'],
725725 );
from line 750
750750
751751 puts "First request - establishing cache"
752752 response1 = client.messages.create(
753 model: "claude-opus-4-8",
753 model: "claude-opus-5",
754754 max_tokens: 16000,
755755 thinking: {
756756 type: "adaptive"
from line 775
775775
776776 puts "\nSecond request - same configuration (cache hit expected)"
777777 response2 = client.messages.create(
778 model: "claude-opus-4-8",
778 model: "claude-opus-5",
779779 max_tokens: 16000,
780780 thinking: {
781781 type: "adaptive"
from line 810
810810
811811 puts "\nThird request - different effort level (cache miss expected)"
812812 response3 = client.messages.create(
813 model: "claude-opus-4-8",
813 model: "claude-opus-5",
814814 max_tokens: 16000,
815815 thinking: {
816816 type: "adaptive"
cli-sdks-libraries/libraries/openai-sdk Changed · +169 / -6 lines
from line 33
3333
3434### Quick start example
3535
36<CodeGroup>
36<CodeGroup exclude="shell">
3737 ```python Python
3838 import os
3939
from line 59
5959 import OpenAI from "openai";
6060
6161 const openai = new OpenAI({
62 apiKey: "ANTHROPIC_API_KEY", // Your Claude API key
62 apiKey: process.env.ANTHROPIC_API_KEY, // Your Claude API key
6363 baseURL: "https://api.anthropic.com/v1/" // Claude API endpoint
6464 });
6565
6666 const response = await openai.chat.completions.create({
67 messages: [{ role: "user", content: "Who are you?" }],
67 messages: [
68 { role: "system", content: "You are a helpful assistant." },
69 { role: "user", content: "Who are you?" }
70 ],
6871 model: "claude-opus-5" // Claude model name
6972 });
7073
7174 console.log(response.choices[0].message.content);
7275 ```
76
77 ```csharp C#
78 using System.ClientModel;
79 using OpenAI;
80 using OpenAI.Chat;
81
82 ChatClient chatClient = new(
83 model: "claude-opus-5", // Claude model name
84 credential: new ApiKeyCredential(
85 Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY")), // Your Claude API key
86 options: new OpenAIClientOptions()
87 {
88 Endpoint = new Uri("https://api.anthropic.com/v1/") // the Claude API endpoint
89 });
90
91 ChatCompletion completion = chatClient.CompleteChat(
92 new SystemChatMessage("You are a helpful assistant."),
93 new UserChatMessage("Who are you?"));
94
95 Console.WriteLine(completion.Content[0].Text);
96 ```
97
98 ```go Go
99 package main
100
101 import (
102 "context"
103 "fmt"
104 "os"
105
106 "github.com/openai/openai-go/v3"
107 "github.com/openai/openai-go/v3/option"
108 )
109
110 func main() {
111 client := openai.NewClient(
112 option.WithAPIKey(os.Getenv("ANTHROPIC_API_KEY")), // Your Claude API key
113 option.WithBaseURL("https://api.anthropic.com/v1/"), // the Claude API endpoint
114 )
115
116 response, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
117 Model: "claude-opus-5", // Claude model name
118 Messages: []openai.ChatCompletionMessageParamUnion{
119 openai.SystemMessage("You are a helpful assistant."),
120 openai.UserMessage("Who are you?"),
121 },
122 })
123 if err != nil {
124 panic(err)
125 }
126
127 fmt.Println(response.Choices[0].Message.Content)
128 }
129 ```
130
131 ```java Java
132 import com.openai.client.OpenAIClient;
133 import com.openai.client.okhttp.OpenAIOkHttpClient;
134 import com.openai.models.chat.completions.ChatCompletion;
135 import com.openai.models.chat.completions.ChatCompletionCreateParams;
136
137 public class QuickStart {
138 public static void main(String[] args) {
139 OpenAIClient client = OpenAIOkHttpClient.builder()
140 .apiKey(System.getenv("ANTHROPIC_API_KEY")) // Your Claude API key
141 .baseUrl("https://api.anthropic.com/v1/") // the Claude API endpoint
142 .build();
143
144 ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
145 .model("claude-opus-5") // Claude model name
146 .addSystemMessage("You are a helpful assistant.")
147 .addUserMessage("Who are you?")
148 .build();
149
150 ChatCompletion completion = client.chat().completions().create(params);
151 System.out.println(completion.choices().get(0).message().content().orElse(""));
152 }
153 }
154 ```
155
156 ```php PHP
157 <?php
158 // There is no official OpenAI PHP SDK, so no example is shown here.
159 // To use Claude from PHP, use the native Claude API instead:
160 // https://platform.claude.com/docs/en/cli-sdks-libraries/overview
161 ```
162
163 ```ruby Ruby
164 require "openai"
165
166 openai = OpenAI::Client.new(
167 api_key: ENV["ANTHROPIC_API_KEY"], # Your Claude API key
168 base_url: "https://api.anthropic.com/v1/" # the Claude API endpoint
169 )
170
171 response = openai.chat.completions.create(
172 model: "claude-opus-5", # Claude model name
173 messages: [
174 {role: "system", content: "You are a helpful assistant."},
175 {role: "user", content: "Who are you?"}
176 ]
177 )
178
179 puts response.choices.first.message.content
180 ```
73181</CodeGroup>
74182
75183## Important OpenAI compatibility limitations
from line 203
95203
96204### Thinking support
97205
98You can enable [thinking](https://platform.claude.com/docs/en/build-with-claude/thinking) by adding the `thinking` parameter. On current models thinking is adaptive, with Claude deciding when and how deeply to think, and on Claude 5 models it is on by default; manually configured extended thinking is a legacy mode. While thinking improves Claude's reasoning for complex tasks, the OpenAI SDK doesn't return Claude's detailed thought process. For full thinking features, including access to Claude's step-by-step reasoning output, use the native Claude API.
206You can enable [thinking](https://platform.claude.com/docs/en/build-with-claude/thinking) by adding the `thinking` parameter. On current models thinking is adaptive, with Claude deciding when and how deeply to think, and on Claude 5 models it is on by default; manually configured extended thinking is a legacy mode. Although thinking improves Claude's reasoning for complex tasks, the OpenAI SDK doesn't return Claude's detailed thought process. For full thinking features, including access to Claude's step-by-step reasoning output, use the native Claude API.
99207
100<CodeGroup>
208<CodeGroup exclude="shell">
101209 ```python Python
102210 response = client.chat.completions.create(
103211 model="claude-sonnet-4-6",
from line 221
113221 // @ts-expect-error
114222 thinking: { type: "enabled", budget_tokens: 2000 }
115223 });
224 ```
225
226 ```csharp C#
227 // The .NET SDK has no extra_body parameter like Python's, so this example
228 // sends the thinking parameter with the SDK's documented protocol method
229 // (a raw JSON request body).
230 BinaryData input = BinaryData.FromString("""
231 {
232 "model": "claude-sonnet-4-6",
233 "messages": [{ "role": "user", "content": "Who are you?" }],
234 "thinking": { "type": "enabled", "budget_tokens": 2000 }
235 }
236 """);
237
238 using BinaryContent content = BinaryContent.Create(input);
239 ClientResult result = chatClient.CompleteChat(content);
240 ```
241
242 ```go Go
243 response, err := client.Chat.Completions.New(
244 context.Background(),
245 openai.ChatCompletionNewParams{
246 Model: "claude-sonnet-4-6",
247 Messages: []openai.ChatCompletionMessageParamUnion{
248 openai.UserMessage("Who are you?"),
249 },
250 },
251 option.WithJSONSet("thinking", map[string]any{"type": "enabled", "budget_tokens": 2000}),
252 )
253 ```
254
255 ```java Java
256 ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
257 .model("claude-sonnet-4-6")
258 .addUserMessage("Who are you?")
259 .putAdditionalBodyProperty("thinking",
260 JsonValue.from(Map.of("type", "enabled", "budget_tokens", 2000)))
261 .build();
262
263 ChatCompletion completion = client.chat().completions().create(params);
264 ```
265
266 ```php PHP
267 <?php
268 // There is no official OpenAI PHP SDK, so no example is shown here.
269 // To use Claude from PHP, use the native Claude API instead:
270 // https://platform.claude.com/docs/en/cli-sdks-libraries/overview
271 ```
272
273 ```ruby Ruby
274 response = openai.chat.completions.create(
275 model: "claude-sonnet-4-6",
276 messages: [{role: "user", content: "Who are you?"}],
277 request_options: {extra_body: {thinking: {type: "enabled", budget_tokens: 2000}}}
278 )
116279 ```
117280</CodeGroup>
118281
manage-claude/compliance-faq Changed · +3 / -3 lines
from line 69
6969 To retrieve message bodies and file contents, use the chat, message, and file endpoints with a Compliance Access Key carrying `read:compliance_user_data`. The same key and scope retrieve transcripts of Cowork and Claude Code sessions on users' machines through the [local session endpoints](https://platform.claude.com/docs/en/manage-claude/compliance-sessions#retrieve-local-sessions), and transcripts of Cowork sessions in the cloud through the [remote session endpoints](https://platform.claude.com/docs/en/manage-claude/compliance-sessions#retrieve-remote-sessions). These endpoints serve Claude Enterprise content only; Claude Console workloads, and Claude API workloads authenticated with an API key, expose administrative and resource events through the Activity Feed but do not expose prompt text or model responses through the Compliance API.
7070 </Accordion>
7171
72 <Accordion title="Do Cowork and Claude Code sessions appear in the Compliance API?">
72 <Accordion title="Do Cowork, Claude Code, Claude Science, and Claude for Microsoft 365 sessions appear in the Compliance API?">
7373 Yes. Cowork sessions in Claude Desktop that run on users' machines, Claude Code sessions (in the terminal, in Claude Desktop, or in an IDE extension), sessions in the Claude Science desktop app, and Claude for Microsoft 365 sessions in Excel, PowerPoint, Word, and Outlook are captured while users are signed in with their Claude Enterprise account and are available through the [local session endpoints](https://platform.claude.com/docs/en/manage-claude/compliance-sessions#retrieve-local-sessions). Cowork sessions started on claude.ai web or mobile, which run in the cloud in Anthropic-managed environments, are available through the [remote session endpoints](https://platform.claude.com/docs/en/manage-claude/compliance-sessions#retrieve-remote-sessions). Each family has a list endpoint that returns session metadata and a messages endpoint that returns the session transcript (user prompts, assistant responses, and tool calls and results). The local family adds a third endpoint that retrieves one session's metadata. All of these endpoints use your existing Compliance Access Key with `read:compliance_user_data`; no new key or scope is needed.
7474
7575 Local sessions are captured as their requests reach the Claude API, so nothing is installed on the device, and on-device activity that never reaches the API is not captured. Claude Code sessions authenticated with a Claude Console API key, Claude Code sessions run through a third-party cloud platform (Amazon Bedrock, Google Cloud, or Microsoft Foundry), and Claude Code on the web are not captured. Claude Code on the web also runs in the cloud in Anthropic-managed environments, but it is not a remote session; the remote session endpoints return Cowork sessions only. Organizations with [HIPAA readiness](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#hipaa-readiness) enabled get no local session data, and sessions for which [zero data retention (ZDR)](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#zero-data-retention-zdr-scope) is in effect are excluded.
from line 77
7777 The local and remote session endpoints are stable for Cowork and Claude Code sessions; coverage of Claude Science and Claude for Microsoft 365 sessions is in beta.
7878 </Accordion>
7979
80 <Accordion title="What do Cowork and Claude Code session transcripts include?">
81 Local and remote session transcripts both carry user prompts, assistant responses, and tool calls and results. For local sessions (Cowork and Claude Code on users' machines), that is what Claude was asked to do and what it returned, not what happened on the device.
80 <Accordion title="What do Cowork, Claude Code, Claude Science, and Claude for Microsoft 365 session transcripts include?">
81 Local and remote session transcripts both carry user prompts, assistant responses, and tool calls and results. For local sessions (on users' machines), that is what Claude was asked to do and what it returned, not what happened on the device.
8282
8383 | Data | Local sessions (on users' machines) | Remote sessions (in the cloud) |
8484 | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
managed-agents/memory Changed · +7 / -7 lines
from line 203
203203</CodeGroup>
204204
205205<Tip>
206 Individual memories within the store are capped at 100 kB (\~25k tokens). A store holds a maximum of 2,000 memories. Structure memory as many small focused files, not a few large ones.
206 Individual memories within the store are capped at 100 kB (\~25k tokens). A store holds a maximum of 10,000 memories. Structure memory as many small focused files, not a few large ones.
207207</Tip>
208208
209209## Attach a memory store to a session
from line 917
917917
918918Every mutation to a memory creates an immutable **memory version** (`memver_...`). Use the version endpoints to audit who changed what and when, to inspect or restore a prior snapshot, and to scrub sensitive content out of history with redact.
919919
920Versions belong to the store (not the individual memory) and survive even after the memory itself is deleted, so the audit trail stays complete. Versions are retained for 30 days; however, the recent versions are always kept regardless of age, so memories that change infrequently might retain history beyond 30 days. The live `memories.retrieve` call always returns the latest version; the version endpoints give you the retained history.
920Versions belong to the store (not the individual memory) and are not deleted when the memory itself is deleted, so the audit trail also covers deleted memories, subject to the retention described below. Versions are retained for 30 days after they are written; however, the recent versions of a live memory are always kept regardless of age, so memories that change infrequently might retain history beyond 30 days. The live `memories.retrieve` call always returns the latest version; the version endpoints give you the retained history.
921921
922There is no dedicated restore endpoint; to roll back, retrieve the version you want and write its `content` back with `memories.update` (or `memories.create` if the parent memory has been deleted, because versions outlive their parent).
922There is no dedicated restore endpoint; to roll back, retrieve the version you want and write its `content` back with `memories.update` (or `memories.create` if the parent memory has been deleted, provided the version you want is still retained).
923923
924924Past memory versions might be deleted after 30 days. To preserve memory history for longer, export versions through the API.
925925
from line 1328
13281328
13291329## Best practices for memory management
13301330
1331When a store reaches its 2,000-memory limit, writes to new memories fail: both direct `memories.create` calls and the agent's file writes to unmapped paths. Existing memories remain readable and editable. The following practices help you stay well under the limit and recover gracefully if you reach it.
1331When a store reaches its 10,000-memory limit, writes to new memories fail: both direct `memories.create` calls and the agent's file writes to unmapped paths. Existing memories remain readable and editable. The following practices help you stay well under the limit and recover gracefully if you reach it.
13321332
1333* **Use focused stores.** Rather than one large general-purpose store, use smaller purpose-built stores: one per user, one for shared domain knowledge, and one for project-specific context. Each store has its own 2,000-memory limit, so keeping stores scoped reduces the chance any single one fills up.
1333* **Use focused stores.** Rather than one large general-purpose store, use smaller purpose-built stores: one per user, one for shared domain knowledge, and one for project-specific context. Each store has its own 10,000-memory limit, so keeping stores scoped reduces the chance any single one fills up.
13341334
13351335* **Condense or prune before the store fills up.** Delete stale or redundant memories with `memories.delete`. You can also run a [dreaming session](https://platform.claude.com/docs/en/managed-agents/dreams), which consolidates fragmented content into a separate new output store rather than modifying the original. Switch your sessions over to that output store, then archive or delete the original.
13361336
models/fable-5/migration-guide Changed · +9 / -3 lines
from line 344
344344
3453451. **Thinking can no longer be disabled:** On Claude Opus 5, thinking is on by default and can be turned off with `thinking: {type: "disabled"}` at an [effort](https://platform.claude.com/docs/en/build-with-claude/effort) level of `high` or below. On `claude-fable-5` and `claude-mythos-5`, [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking) is always on, and `thinking: {type: "disabled"}` returns a 400 error at any effort level. Remove the `thinking: {type: "disabled"}` configuration and use lower effort levels to control token spend instead.
346346
347 If your Claude Opus 5 requests disabled thinking, the response shape changes: a response can begin with one or more `thinking` blocks before the first `text` block, returned with an empty `thinking` field at the default `display: "omitted"` (the same default as Claude Opus 5). Code that reads the reply by position, such as `content[0].text` or a stream handler that treats the first content block as text, must select content blocks by their `type` field instead, and tool-use loops must pass `thinking` blocks back complete and unmodified with their tool results. The API rejects edited, reordered, or partially dropped thinking blocks with a 400 error (see [Preserving thinking blocks](https://platform.claude.com/docs/en/build-with-claude/thinking#preserving-thinking-blocks)). Thinking tokens are billed as output tokens even when the thinking text is not returned.
348
3473492. **Pricing:** Claude Fable 5 and Claude Mythos 5 are priced at $10 USD per million input tokens and $50 USD per million output tokens, compared with $5 USD and $25 USD for Claude Opus 5. See [Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing).
348350
3493513. **Priority Tier:** [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) is not supported on Claude Opus 5, so no existing traffic is affected. If your organization has a Priority Tier commitment, Claude Fable 5 supports it; Claude Mythos 5 does not.
from line 356
354356
355357* Update the model name from `claude-opus-5` to `claude-fable-5` (or `claude-mythos-5`).
356358* Remove any `thinking: {type: "disabled"}` configuration; it returns a 400 error on `claude-fable-5` and `claude-mythos-5`. Use lower [effort](https://platform.claude.com/docs/en/build-with-claude/effort) levels to control token spend instead, and revisit `max_tokens` for workloads that ran with thinking disabled on Claude Opus 5.
359* If those workloads read content by position, such as `content[0].text`, update them to select content blocks by `type`: `thinking` blocks now arrive before `text` blocks. Pass `thinking` blocks back complete and unmodified in tool-use loops; modified blocks return a 400 error.
357360* If your organization has a zero data retention (ZDR) arrangement, confirm eligibility before migrating. See [Model-specific data retention requirements](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).
358* Re-baseline cost on your own workloads. Token counts are roughly unchanged; per-token pricing differs.
361* Re-baseline cost on your own workloads. Token counts are roughly unchanged; per-token pricing differs, and workloads that ran with thinking disabled now produce thinking tokens, which are billed as output tokens.
359362
360363## Migrating to Claude Mythos 5 and Claude Fable 5 from Claude Opus 4.8
361364
from line 384
381384
3823851. **Adaptive thinking is always on:** [Adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking) is the only thinking mode on `claude-fable-5` and `claude-mythos-5`. The model determines when and how much to think on each request, and no `thinking` configuration is required. `thinking: {type: "disabled"}` returns an error. Use the [effort parameter](https://platform.claude.com/docs/en/build-with-claude/effort) to control thinking depth.
383386
384 The behavior change to check: on Claude Opus 4.8, requests without a `thinking` field run without thinking; on `claude-fable-5` and `claude-mythos-5`, those same requests run with adaptive thinking. `max_tokens` remains a hard limit on total output, thinking plus response text, so revisit it for workloads that ran without thinking on Claude Opus 4.8. See [Cost control](https://platform.claude.com/docs/en/build-with-claude/thinking-steering-and-cost#cost-control).
387 The behavior change to check: on Claude Opus 4.8, requests without a `thinking` field run without thinking; on `claude-fable-5` and `claude-mythos-5`, those same requests run with adaptive thinking. `max_tokens` remains a hard limit on total output, thinking plus response text, so revisit it for workloads that ran without thinking on Claude Opus 4.8. See [Cost control](https://platform.claude.com/docs/en/build-with-claude/thinking-steering-and-cost#cost-control). Responses can also begin with one or more `thinking` blocks before the first `text` block, so code that reads the reply by position (for example, `content[0].text`, or a stream handler that treats the first content block as text) must select content blocks by their `type` field instead. Thinking tokens are billed as output tokens even when the thinking text is not returned to you, so a workload that ran without thinking on Claude Opus 4.8 produces more output tokens per request, in addition to the per-token price difference.
385388
389 If you run a tool-use loop, pass the `thinking` blocks from each assistant response back to the API complete and unmodified when you return tool results, including blocks whose `thinking` field is empty. Echo the assistant message as received rather than filtering its content blocks by type or rebuilding it: the API rejects edited, reordered, or partially dropped thinking blocks with a 400 error. See [Preserving thinking blocks](https://platform.claude.com/docs/en/build-with-claude/thinking#preserving-thinking-blocks).
390
386391 Before (Claude Opus 4.8):
387392
388393 <CodeGroup>
from line 693
688693* If your organization has a zero data retention (ZDR) arrangement, confirm eligibility before migrating. `claude-fable-5` and `claude-mythos-5` require 30-day data retention; on the Claude API, requests to `claude-fable-5` that do not meet this requirement return a 400 `invalid_request_error`. Claude Opus 4.8 remains available under ZDR. See [Model-specific data retention requirements](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).
689694* Update the model name from `claude-opus-4-8` to `claude-fable-5` (or `claude-mythos-5`).
690695* Remove any `thinking: {type: "disabled"}` configuration. Disabling thinking returns an error on `claude-fable-5` and `claude-mythos-5`, and requests without a `thinking` field run with adaptive thinking.
696* Update response parsing that reads content by position, such as `content[0].text`: with adaptive thinking always on, `thinking` blocks arrive before `text` blocks. Select content blocks by `type` instead, and pass `thinking` blocks back complete and unmodified in tool-use loops; modified blocks return a 400 error. See [Preserving thinking blocks](https://platform.claude.com/docs/en/build-with-claude/thinking#preserving-thinking-blocks).
691697* If you removed manual extended thinking and assistant prefills during earlier migrations, no action is needed: both remain unsupported on `claude-fable-5` and `claude-mythos-5`.
692698* Verify any code that parses the `thinking` field treats it as display text only and passes thinking blocks back unchanged when continuing on the same model. `thinking.display` defaults to `"omitted"` on `claude-fable-5` and `claude-mythos-5`, the same as on Claude Opus 4.8; set `display: "summarized"` to receive readable summaries. See [Thinking output on Claude Fable 5 and Claude Mythos 5](https://platform.claude.com/docs/en/build-with-claude/thinking#thinking-output-on-claude-fable-5-and-claude-mythos-5).
693699* If you replay conversation history on another model, strip `thinking` and `redacted_thinking` blocks from prior assistant turns first. Thinking blocks from `claude-fable-5` and `claude-mythos-5` are tied to the model that produced them, and models other than Claude Fable 5 and Claude Mythos 5 silently ignore them. Stripping keeps cross-model requests minimal and uniform. The exception is redeeming a [fallback credit](https://platform.claude.com/docs/en/build-with-claude/fallback-credit), which requires the request body echoed under that feature's exact rules.
694700* If you migrate to Claude Fable 5, handle `stop_reason: "refusal"` and read the `stop_details.category` field. To re-run refused requests on another model automatically, consider the opt-in `fallbacks` parameter (beta). See [Refusals and fallback](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback).
695701* Re-evaluate your `effort` setting. Start at `high` for most tasks, including workloads that ran at `xhigh` on Claude Opus 4.8.
696* Re-baseline cost and latency on your own workloads. Token counts are roughly unchanged when migrating from `claude-opus-4-8`; per-token pricing differs.
702* Re-baseline cost and latency on your own workloads. Token counts are roughly unchanged when migrating from `claude-opus-4-8`; per-token pricing differs, and thinking tokens are billed as output tokens, so workloads that ran without thinking produce more output tokens per request.
697703
models/opus-5/migration-guide Changed · +32 / -12 lines
from line 20
2020
2121Claude Opus 5 is a step-change improvement over Claude Opus 4.8, strong on deep reasoning, agentic and long-horizon tasks, and test-time compute scaling. For behavioral differences and model-specific prompting patterns, see [Prompting Claude Opus 5](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5).
2222
23Claude Opus 5 is a drop-in upgrade for Claude Opus 4.8 at the same pricing of $5 per million input tokens and $25 per million output tokens; see [Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing). There are two breaking changes for code already running on Claude Opus 4.8, covered under Breaking changes below. Claude Opus 5 supports the same set of features as Claude Opus 4.8, including the [1M token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows) (the default, with no beta header), [128k max output tokens](https://platform.claude.com/docs/en/models/overview), [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking), [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching), [batch processing](https://platform.claude.com/docs/en/build-with-claude/batch-processing), the [Files API](https://platform.claude.com/docs/en/build-with-claude/files), [PDF support](https://platform.claude.com/docs/en/build-with-claude/pdf-support), [vision](https://platform.claude.com/docs/en/build-with-claude/vision), and server-side and client-side [tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview), with two exceptions: [web fetch](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool) is not available on Claude Opus 5, and [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) is not supported on Claude Opus 5. See each tool page for model availability.
23Claude Opus 5 is a drop-in upgrade for Claude Opus 4.8 at the same pricing of $5 USD per million input tokens and $25 USD per million output tokens; see [Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing). There are two breaking changes for code already running on Claude Opus 4.8, covered under [Breaking changes](https://platform.claude.com/docs/en/models/opus-5/migration-guide#breaking-changes). Claude Opus 5 supports the same set of features as Claude Opus 4.8, including the [1M token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows) (the default, with no beta header), [128k max output tokens](https://platform.claude.com/docs/en/models/overview), [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking), [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching), [batch processing](https://platform.claude.com/docs/en/build-with-claude/batch-processing), the [Files API](https://platform.claude.com/docs/en/build-with-claude/files), [PDF support](https://platform.claude.com/docs/en/build-with-claude/pdf-support), [vision](https://platform.claude.com/docs/en/build-with-claude/vision), and server-side and client-side [tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview), with two exceptions: [web fetch](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool) is not available on Claude Opus 5, and [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) is not supported on Claude Opus 5. See each tool page for model availability.
2424
2525## Migrating to Claude Opus 5 from Claude Opus 4.8
2626
2727<Note>
28 This section covers the delta from Claude Opus 4.8 only. If your code is on Claude Opus 4.7 or earlier, use the sections below instead: [Migrating to Claude Opus 5 from Claude Opus 4.7](https://platform.claude.com/docs/en/models/opus-5/migration-guide#migrating-from-claude-opus-47) or [Migrating to Claude Opus 5 from Claude Opus 4.6 and earlier Opus models](https://platform.claude.com/docs/en/models/opus-5/migration-guide#migrating-from-claude-opus-46). They include this delta plus the breaking changes from earlier models (sampling parameters rejected, manual extended thinking rejected, prefill removed, new tokenizer).
28 This section covers the delta from Claude Opus 4.8 only. If your code is on Claude Opus 4.7 or earlier, use these sections instead: [Migrating to Claude Opus 5 from Claude Opus 4.7](https://platform.claude.com/docs/en/models/opus-5/migration-guide#migrating-from-claude-opus-47) or [Migrating to Claude Opus 5 from Claude Opus 4.6 and earlier Opus models](https://platform.claude.com/docs/en/models/opus-5/migration-guide#migrating-from-claude-opus-46). They include this delta plus the breaking changes from earlier models (sampling parameters rejected, manual extended thinking rejected, prefill removed, new tokenizer).
2929</Note>
3030
3131### Update your model name
from line 40
4040
4141### Breaking changes
4242
431. **Thinking on by default:** On Claude Opus 4.8, requests without a `thinking` field run without thinking; on Claude Opus 5, the same requests run with [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking). `max_tokens` remains a hard limit on total output, thinking plus response text, so revisit it for workloads that ran without thinking on Claude Opus 4.8. To preserve the old behavior, pass `thinking: {type: "disabled"}`, subject to the effort cap in the next item; note that with thinking disabled the model can occasionally emit tool calls as plain text or include internal XML tags in its visible output, so prefer lower effort levels with thinking enabled where you can, and see [Running with thinking disabled](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5#running-with-thinking-disabled) for mitigations where you can't.
431. **Thinking on by default:** On Claude Opus 4.8, requests without a `thinking` field run without thinking; on Claude Opus 5, the same requests run with [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking). `max_tokens` remains a hard limit on total output, thinking plus response text, so revisit it for workloads that ran without thinking on Claude Opus 4.8. Thinking tokens are billed as output tokens even when the thinking text is not returned to you, so although per-token pricing is unchanged, a workload that ran without thinking on Claude Opus 4.8 can produce more output tokens per request on Claude Opus 5; see [Cost control](https://platform.claude.com/docs/en/build-with-claude/thinking-steering-and-cost#cost-control). To preserve the old behavior, pass `thinking: {type: "disabled"}`, subject to the effort cap in the next item; note that with thinking disabled the model can occasionally emit tool calls as plain text or include internal XML tags in its visible output, so prefer lower effort levels with thinking enabled where you can, and see [Running with thinking disabled](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5#running-with-thinking-disabled) for mitigations where you can't.
4444
45 The response shape changes with it. With thinking on, a response can begin with one or more `thinking` blocks before the first `text` block, and because `thinking.display` defaults to `"omitted"` on Claude Opus 5, those blocks arrive with an empty `thinking` field alongside their `signature`. Code that reads the reply by position, such as `content[0].text` or a stream handler that treats the first `content_block_start` event as text, breaks on these responses. Select content blocks by their `type` field instead: read `text` from the blocks whose `type` is `"text"`, and branch on the block type when handling stream events. To receive readable thinking summaries instead of an empty `thinking` field, set `display: "summarized"`; see [Controlling thinking display](https://platform.claude.com/docs/en/build-with-claude/thinking#controlling-thinking-display).
46
47 If you run a tool-use loop, pass the `thinking` blocks from each assistant response back to the API complete and unmodified when you return tool results, including blocks whose `thinking` field is empty. Echo the assistant message as received rather than filtering its content blocks by type or rebuilding it: the API rejects edited, reordered, or partially dropped thinking blocks with a 400 error. See [Preserving thinking blocks](https://platform.claude.com/docs/en/build-with-claude/thinking#preserving-thinking-blocks).
48
45492. **Disabling thinking is capped at `high` effort:** You can still turn thinking off with `thinking: {type: "disabled"}`, but only at an [effort](https://platform.claude.com/docs/en/build-with-claude/effort) level of `high` or below. A request that combines `thinking: {type: "disabled"}` with effort `xhigh` or `max` returns a 400 error. Claude Opus 4.8 accepts this combination, so audit requests that disable thinking before you migrate.
4650
4751 The check is enforced on each request: every request's effort and thinking configuration is validated independently, so a request that raises effort to `xhigh` or `max` while thinking is disabled is rejected even if earlier requests in the conversation were accepted.
from line 105
101105
102106* Update the model name from `claude-opus-4-8` to `claude-opus-5`.
103107* Review workloads that ran without a `thinking` field: they run with thinking on Claude Opus 5. Revisit `max_tokens`, which remains a hard limit on total output (thinking plus response text), or pass `thinking: {type: "disabled"}` at effort `high` or below to preserve the old behavior. If you disable thinking, review [Running with thinking disabled](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5#running-with-thinking-disabled) for the output artifacts that can appear and their prompting mitigations.
108* Update response parsing that reads content by position, such as `content[0].text` or a stream handler that assumes the first content block is text: with thinking on, `thinking` blocks arrive before `text` blocks. Select content blocks by `type` instead.
109* If you run a tool-use loop, pass `thinking` blocks back complete and unmodified when you return tool results; modified blocks return a 400 error. See [Preserving thinking blocks](https://platform.claude.com/docs/en/build-with-claude/thinking#preserving-thinking-blocks).
110* Verify any code that parses the `thinking` field treats it as display text only. `thinking.display` defaults to `"omitted"` on Claude Opus 5, the same as on Claude Opus 4.8, so thinking blocks arrive with an empty `thinking` field; set `display: "summarized"` to receive readable summaries. See [Controlling thinking display](https://platform.claude.com/docs/en/build-with-claude/thinking#controlling-thinking-display).
104111* Audit requests that disable thinking: `thinking: {type: "disabled"}` with effort `xhigh` or `max` returns a 400 error, enforced on each request. Re-enable thinking or lower the effort to `high` or below.
105112* Re-evaluate your `effort` setting: run a fresh [effort](https://platform.claude.com/docs/en/build-with-claude/effort) sweep on your own evals rather than carrying over a setting tuned for an earlier model. `low` and `medium` effort are worth testing as cost and latency controls, and test `max` effort where maximum capability matters more than token spend. If you run at `xhigh` or `max` effort, raise `max_tokens` to at least 64k as a starting point.
106113* Review prompts near the caching minimum: prompts of 512 tokens or more can now create cache entries, down from 1,024 tokens on Claude Opus 4.8.
from line 116
109116* For agentic workloads, consider [task budgets](https://platform.claude.com/docs/en/build-with-claude/task-budgets) (beta) and mid-conversation tool changes (beta).
110117* Re-tune length and verbosity prompts: default visible responses and written deliverables run longer on Claude Opus 5, and lowering effort reduces thinking volume without reliably shortening the visible response. Prompt explicitly for conciseness or a target length. See [Response length and verbosity](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5#response-length-and-verbosity) and [Written deliverable length](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5#written-deliverable-length).
111118* Remove verification and self-check instructions carried over from prompts tuned for earlier models (they cause over-verification on Claude Opus 5), constrain task scope explicitly for narrow tasks, and in multi-agent frameworks steer or cap subagent delegation. See [Task scope and over-verification](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5#task-scope-and-over-verification) and [Controlling subagent spawning](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5#controlling-subagent-spawning).
112* Re-baseline cost and latency on your own workloads.
119* Re-baseline cost and latency on your own workloads. Per-token pricing is unchanged from Claude Opus 4.8, but thinking tokens are billed as output tokens, so workloads that ran without thinking can produce more output tokens per request.
113120
114121## Migrating to Claude Opus 5 from Claude Opus 4.7
115122
116Claude Opus 5 should have strong out-of-the-box performance on existing Claude Opus 4.7 prompts and evals, at the same pricing of $5 per million input tokens and $25 per million output tokens. It supports the same set of features as Claude Opus 4.7, including the [1M token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows), [128k max output tokens](https://platform.claude.com/docs/en/models/overview), [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking), [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching), [batch processing](https://platform.claude.com/docs/en/build-with-claude/batch-processing), the [Files API](https://platform.claude.com/docs/en/build-with-claude/files), [PDF support](https://platform.claude.com/docs/en/build-with-claude/pdf-support), [vision](https://platform.claude.com/docs/en/build-with-claude/vision), and server-side and client-side [tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview), with two exceptions: [web fetch](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool) is not available on Claude Opus 5, and [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) is not supported on Claude Opus 5. It also adds [mid-conversation system messages](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages) and publicly documents [refusal stop details](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback#refusal-response). On the Claude API and Google Cloud, Claude Opus 5 also supports [computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) as the stable `computer_toolset_20260801` toolset and the [browser use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool) for tasks inside webpages, neither of which Claude Opus 4.7 supports; existing integrations on the earlier `computer_20251124` version continue to work unchanged on both models. To upgrade an existing integration, see [Migrate from `computer_20251124`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124).
123Claude Opus 5 should have strong out-of-the-box performance on existing Claude Opus 4.7 prompts and evals, at the same pricing of $5 USD per million input tokens and $25 USD per million output tokens. It supports the same set of features as Claude Opus 4.7, including the [1M token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows), [128k max output tokens](https://platform.claude.com/docs/en/models/overview), [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking), [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching), [batch processing](https://platform.claude.com/docs/en/build-with-claude/batch-processing), the [Files API](https://platform.claude.com/docs/en/build-with-claude/files), [PDF support](https://platform.claude.com/docs/en/build-with-claude/pdf-support), [vision](https://platform.claude.com/docs/en/build-with-claude/vision), and server-side and client-side [tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview), with two exceptions: [web fetch](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool) is not available on Claude Opus 5, and [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) is not supported on Claude Opus 5. It also adds [mid-conversation system messages](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages) and publicly documents [refusal stop details](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback#refusal-response). On the Claude API and Google Cloud, Claude Opus 5 also supports [computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) as the stable `computer_toolset_20260801` toolset and the [browser use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool) for tasks inside webpages, neither of which Claude Opus 4.7 supports; existing integrations on the earlier `computer_20251124` version continue to work unchanged on both models. To upgrade an existing integration, see [Migrate from `computer_20251124`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124).
117124
118125<Note>
119126 If your code is on Claude Opus 4.6 or earlier, use [Migrating to Claude Opus 5 from Claude Opus 4.6 and earlier Opus models](https://platform.claude.com/docs/en/models/opus-5/migration-guide#migrating-from-claude-opus-46) instead. That section includes breaking changes (sampling parameters rejected, manual extended thinking rejected, new tokenizer) that the upgrade from Claude Opus 4.7 alone does not cover.
from line 136
129136
130137### Breaking changes
131138
1321. **Thinking on by default:** On Claude Opus 4.7, requests without a `thinking` field run without thinking; on Claude Opus 5, the same requests run with [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking). `max_tokens` remains a hard limit on total output, thinking plus response text, so revisit it for workloads that ran without thinking on Claude Opus 4.7. To preserve the old behavior, pass `thinking: {type: "disabled"}`, subject to the effort cap in the next item; note that with thinking disabled the model can occasionally emit tool calls as plain text or include internal XML tags in its visible output, so prefer lower effort levels with thinking enabled where you can, and see [Running with thinking disabled](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5#running-with-thinking-disabled) for mitigations where you can't.
1391. **Thinking on by default:** On Claude Opus 4.7, requests without a `thinking` field run without thinking; on Claude Opus 5, the same requests run with [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking). `max_tokens` remains a hard limit on total output, thinking plus response text, so revisit it for workloads that ran without thinking on Claude Opus 4.7. Thinking tokens are billed as output tokens even when the thinking text is not returned to you, so although per-token pricing is unchanged, a workload that ran without thinking on Claude Opus 4.7 can produce more output tokens per request on Claude Opus 5; see [Cost control](https://platform.claude.com/docs/en/build-with-claude/thinking-steering-and-cost#cost-control). To preserve the old behavior, pass `thinking: {type: "disabled"}`, subject to the effort cap in the next item; note that with thinking disabled the model can occasionally emit tool calls as plain text or include internal XML tags in its visible output, so prefer lower effort levels with thinking enabled where you can, and see [Running with thinking disabled](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5#running-with-thinking-disabled) for mitigations where you can't.
133140
141 The response shape changes with it. With thinking on, a response can begin with one or more `thinking` blocks before the first `text` block, and because `thinking.display` defaults to `"omitted"` on Claude Opus 5, those blocks arrive with an empty `thinking` field alongside their `signature`. Code that reads the reply by position, such as `content[0].text` or a stream handler that treats the first `content_block_start` event as text, breaks on these responses. Select content blocks by their `type` field instead: read `text` from the blocks whose `type` is `"text"`, and branch on the block type when handling stream events. To receive readable thinking summaries instead of an empty `thinking` field, set `display: "summarized"`; see [Controlling thinking display](https://platform.claude.com/docs/en/build-with-claude/thinking#controlling-thinking-display).
142
143 If you run a tool-use loop, pass the `thinking` blocks from each assistant response back to the API complete and unmodified when you return tool results, including blocks whose `thinking` field is empty. Echo the assistant message as received rather than filtering its content blocks by type or rebuilding it: the API rejects edited, reordered, or partially dropped thinking blocks with a 400 error. See [Preserving thinking blocks](https://platform.claude.com/docs/en/build-with-claude/thinking#preserving-thinking-blocks).
144
1341452. **Disabling thinking is capped at `high` effort:** You can turn thinking off with `thinking: {type: "disabled"}`, but only at an [effort](https://platform.claude.com/docs/en/build-with-claude/effort) level of `high` or below. A request that combines `thinking: {type: "disabled"}` with effort `xhigh` or `max` returns a 400 error. Claude Opus 4.7 accepts this combination, so audit requests that disable thinking before you migrate.
135146
136147 The check is enforced on each request: every request's effort and thinking configuration is validated independently, so a request that raises effort to `xhigh` or `max` while thinking is disabled is rejected even if earlier requests in the conversation were accepted.
from line 217
206217
207218* Update model name from `claude-opus-4-7` to `claude-opus-5` (or update aliases).
208219* Review workloads that ran without a `thinking` field: they run with thinking on Claude Opus 5. Revisit `max_tokens`, which remains a hard limit on total output (thinking plus response text), or pass `thinking: {type: "disabled"}` at effort `high` or below to preserve the old behavior. If you disable thinking, review [Running with thinking disabled](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5#running-with-thinking-disabled) for the output artifacts that can appear and their prompting mitigations.
220* Update response parsing that reads content by position, such as `content[0].text` or a stream handler that assumes the first content block is text: with thinking on, `thinking` blocks arrive before `text` blocks. Select content blocks by `type` instead.
221* If you run a tool-use loop, pass `thinking` blocks back complete and unmodified when you return tool results; modified blocks return a 400 error. See [Preserving thinking blocks](https://platform.claude.com/docs/en/build-with-claude/thinking#preserving-thinking-blocks).
222* Verify any code that parses the `thinking` field treats it as display text only. `thinking.display` defaults to `"omitted"` on Claude Opus 5, the same as on Claude Opus 4.7, so thinking blocks arrive with an empty `thinking` field; set `display: "summarized"` to receive readable summaries. See [Controlling thinking display](https://platform.claude.com/docs/en/build-with-claude/thinking#controlling-thinking-display).
209223* Audit requests that disable thinking: `thinking: {type: "disabled"}` with effort `xhigh` or `max` returns a 400 error, enforced on each request. Re-enable thinking or lower the effort to `high` or below.
210224* If you removed sampling parameters during the Opus 4.7 migration, no action is needed. If you re-added them with a 400-retry path, remove that retry path.
211225* Re-evaluate your `effort` setting: run a fresh [effort](https://platform.claude.com/docs/en/build-with-claude/effort) sweep on your own evals rather than carrying over a setting tuned for Claude Opus 4.7. Test `low` and `medium` effort as cost and latency controls, and `max` effort where maximum capability matters more than token spend. If you run at `xhigh` or `max` effort, raise `max_tokens` to at least 64k as a starting point.
from line 232
218232* If you used fast mode on Claude Opus 4.7, no request changes are needed beyond the model ID: `speed: "fast"` and the `fast-mode-2026-02-01` beta header work unchanged on Claude Opus 5.
219233* For agentic workloads, consider [task budgets](https://platform.claude.com/docs/en/build-with-claude/task-budgets) (beta) and mid-conversation tool changes (beta).
220234* Re-tune length and verbosity prompts, and remove verification and self-check instructions carried over from prompts tuned for earlier models.
221* Re-baseline cost and latency at your chosen effort level.
235* Re-baseline cost and latency at your chosen effort level. Per-token pricing is unchanged from Claude Opus 4.7, but thinking tokens are billed as output tokens, so workloads that ran without thinking can produce more output tokens per request.
222236
223237## Migrating to Claude Opus 5 from Claude Opus 4.6 and earlier Opus models
224238
225Claude Opus 5 should have strong out-of-the-box performance on existing Claude Opus 4.6 prompts and evals at the same pricing, but there are a handful of behavioral and API changes worth knowing about as you migrate. Most of these changes took effect in Claude Opus 4.7; two more, thinking on by default and an effort cap on disabling thinking, take effect on Claude Opus 5. All of them are covered below, so this section is complete for code coming straight from Claude Opus 4.6. Claude Opus 5 supports the same set of features as Claude Opus 4.6, including:
239Claude Opus 5 should have strong out-of-the-box performance on existing Claude Opus 4.6 prompts and evals at the same pricing, but there are a handful of behavioral and API changes worth knowing about as you migrate. Most of these changes took effect in Claude Opus 4.7; two more, thinking on by default and an effort cap on disabling thinking, take effect on Claude Opus 5. All of them are covered in this section, so it is complete for code coming straight from Claude Opus 4.6. Claude Opus 5 supports the same set of features as Claude Opus 4.6, including:
226240
227241* [1M token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows) at standard API pricing with no long-context premium
228242* [128k max output tokens](https://platform.claude.com/docs/en/models/overview)
from line 545
531545
532546 Adaptive thinking is steerable through prompting and the [effort parameter](https://platform.claude.com/docs/en/build-with-claude/effort); see [Choosing an effort level](https://platform.claude.com/docs/en/models/opus-5/migration-guide#choosing-an-effort-level).
533547
5342. **Thinking on by default:** On Claude Opus 4.6 and Claude Opus 4.7, requests without a `thinking` field run without thinking; on Claude Opus 5, the same requests run with [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking). `max_tokens` remains a hard limit on total output, thinking plus response text, so revisit it for workloads that ran without thinking. To preserve the old behavior, pass `thinking: {type: "disabled"}`, subject to the effort cap in the next item; note that with thinking disabled the model can occasionally emit tool calls as plain text or include internal XML tags in its visible output, so prefer lower effort levels with thinking enabled where you can, and see [Running with thinking disabled](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5#running-with-thinking-disabled) for mitigations where you can't.
5482. **Thinking on by default:** On Claude Opus 4.6 and Claude Opus 4.7, requests without a `thinking` field run without thinking; on Claude Opus 5, the same requests run with [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking). `max_tokens` remains a hard limit on total output, thinking plus response text, so revisit it for workloads that ran without thinking. Thinking tokens are billed as output tokens even when the thinking text is not returned to you, so although per-token pricing is unchanged, a workload that ran without thinking can produce more output tokens per request on Claude Opus 5; see [Cost control](https://platform.claude.com/docs/en/build-with-claude/thinking-steering-and-cost#cost-control). To preserve the old behavior, pass `thinking: {type: "disabled"}`, subject to the effort cap in the next item; note that with thinking disabled the model can occasionally emit tool calls as plain text or include internal XML tags in its visible output, so prefer lower effort levels with thinking enabled where you can, and see [Running with thinking disabled](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5#running-with-thinking-disabled) for mitigations where you can't.
535549
550 The response shape changes with it. With thinking on, a response can begin with one or more `thinking` blocks before the first `text` block, and because thinking content is omitted by default on Claude Opus 5 (item 5 in this list), those blocks arrive with an empty `thinking` field alongside their `signature`. Code that reads the reply by position, such as `content[0].text` or a stream handler that treats the first `content_block_start` event as text, breaks on these responses. Select content blocks by their `type` field instead: read `text` from the blocks whose `type` is `"text"`, and branch on the block type when handling stream events.
551
552 If you run a tool-use loop, pass the `thinking` blocks from each assistant response back to the API complete and unmodified when you return tool results, including blocks whose `thinking` field is empty. Echo the assistant message as received rather than filtering its content blocks by type or rebuilding it: the API rejects edited, reordered, or partially dropped thinking blocks with a 400 error. See [Preserving thinking blocks](https://platform.claude.com/docs/en/build-with-claude/thinking#preserving-thinking-blocks).
553
5365543. **Disabling thinking is capped at `high` effort:** You can turn thinking off with `thinking: {type: "disabled"}`, but only at an [effort](https://platform.claude.com/docs/en/build-with-claude/effort) level of `high` or below. A request that combines `thinking: {type: "disabled"}` with effort `xhigh` or `max` returns a 400 error on Claude Opus 5, enforced on each request. Audit requests that disable thinking before you migrate: re-enable thinking or lower the effort to `high` or below.
537555
5385564. **Sampling parameters removed:** Setting `temperature`, `top_p`, or `top_k` to any non-default value on Claude Opus 4.7 or later models, including Claude Opus 5, returns a 400 error. The Python SDK (v1.0 and later) does not define them, and passing them raises a `TypeError`. The safest migration path is to omit these parameters entirely from request payloads. Prompting is the recommended way to guide model behavior on Claude Opus 5. If you were using `temperature = 0` for determinism, note that it never guaranteed identical outputs on prior models.
from line 626
608626
609627### Behavior changes
610628
611Claude Opus 4.7 introduced several behavioral differences from Claude Opus 4.6 that are not API breaking changes but may require prompt updates or scaffolding removal. They carry forward to Claude Opus 5, with the adjustments noted below.
629Claude Opus 4.7 introduced several behavioral differences from Claude Opus 4.6 that are not API breaking changes but may require prompt updates or scaffolding removal. They carry forward to Claude Opus 5, with the adjustments noted in this list.
612630
6136311. **Response length varies by use case:** Claude Opus 4.7 calibrates response length to how complex it judges the task to be, rather than defaulting to a fixed verbosity. This usually means shorter answers on simple lookups and much longer ones on open-ended analysis.
614632
from line 767
749767* Remove `temperature`, `top_p`, and `top_k` from request payloads.
750768* Replace `thinking: {type: "enabled", budget_tokens: N}` with `thinking: {type: "adaptive"}` plus the [effort parameter](https://platform.claude.com/docs/en/build-with-claude/effort), or remove the `thinking` field entirely; adaptive thinking is on by default on Claude Opus 5.
751769* Review workloads that ran without a `thinking` field: they run with thinking on Claude Opus 5. Revisit `max_tokens`, which remains a hard limit on total output (thinking plus response text), or pass `thinking: {type: "disabled"}` at effort `high` or below to preserve the old behavior.
770* Update response parsing that reads content by position, such as `content[0].text` or a stream handler that assumes the first content block is text: with thinking on, `thinking` blocks arrive before `text` blocks. Select content blocks by `type` instead.
771* If you run a tool-use loop, pass `thinking` blocks back complete and unmodified when you return tool results; modified blocks return a 400 error. See [Preserving thinking blocks](https://platform.claude.com/docs/en/build-with-claude/thinking#preserving-thinking-blocks).
752772* Audit requests that disable thinking: `thinking: {type: "disabled"}` with effort `xhigh` or `max` returns a 400 error, enforced on each request. Re-enable thinking or lower the effort to `high` or below.
753773* Remove any assistant-message prefills.
754774* If your UI displays thinking content, explicitly opt in to thinking summarization.
755* Re-benchmark end-to-end cost and latency under the updated tokenization.
775* Re-benchmark end-to-end cost and latency under the updated tokenization; thinking tokens are billed as output tokens, so workloads that ran without thinking can also produce more output tokens per request.
756776* Re-tune `max_tokens` to account for the updated tokenization.
757777* Re-test any client-side token-count estimations.
758778* If your application sends images, re-budget for [high-resolution image support](https://platform.claude.com/docs/en/build-with-claude/vision#high-resolution-image-support-on-claude-opus-4-7) (up to approximately 3x more image tokens per full-resolution image). Downsample before sending if you do not need the additional fidelity.
from line 1362
13421362
13431363### What changed
13441364
13451. **Pricing:** Claude Opus 5 is priced at $5 per million input tokens and $25 per million output tokens. Claude Sonnet 5 is priced at $2/$10 per million input/output tokens. See [Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing) for complete pricing.
13651. **Pricing:** Claude Opus 5 is priced at $5 USD per million input tokens and $25 USD per million output tokens. Claude Sonnet 5 is priced at $2/$10 USD per million input/output tokens. See [Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing) for complete pricing.
13461366
134713672. **Disabling thinking is capped at `high` effort:** On Claude Sonnet 5, `thinking: {type: "disabled"}` is accepted at any effort level. On Claude Opus 5, it is accepted only at an [effort](https://platform.claude.com/docs/en/build-with-claude/effort) level of `high` or below; a request that combines `thinking: {type: "disabled"}` with effort `xhigh` or `max` returns a 400 error, enforced on each request. Audit requests that disable thinking before you migrate.
13481368
models/opus-5/whats-new-opus-5 Changed · +14 / -12 lines
from line 4
44description: Overview of new features and behavior changes in Claude Opus 5.
55---
66
7Claude Opus 5 is a step-change improvement over Claude Opus 4.8, with the largest gains in deep reasoning, agentic and long-horizon tasks, and test-time compute scaling. This page summarizes everything new in Claude Opus 5, including thinking on by default, mid-conversation tool changes, and a breaking change to when thinking can be disabled.
7Claude Opus 5 is a step-change improvement over Claude Opus 4.8, with the largest gains in deep reasoning, agentic and long-horizon tasks, and test-time compute scaling. This page summarizes everything new in Claude Opus 5, including mid-conversation tool changes and two breaking changes for code running on Claude Opus 4.8: thinking is on by default, and thinking can be disabled only at effort `high` or below.
88
99## New model
1010
from line 12
1212| ------------- | --------------- | ---------------------------------------------- |
1313| Claude Opus 5 | `claude-opus-5` | For complex agentic coding and enterprise work |
1414
15Claude Opus 5 has a [1M token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows) (1M tokens is both the default and the maximum; there is no smaller context variant), 128k max output tokens, and [thinking](https://platform.claude.com/docs/en/build-with-claude/thinking) on by default.
15Claude Opus 5 has a [1M token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows) (1M tokens is both the default and the maximum; there is no smaller context variant), 128k max output tokens, and [thinking](https://platform.claude.com/docs/en/build-with-claude/thinking) on by default. [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) is not supported on Claude Opus 5.
1616
1717For complete pricing and specs, see the [models overview](https://platform.claude.com/docs/en/models/overview).
1818
from line 38
3838
3939### Thinking on by default
4040
41On Claude Opus 4.8, requests run without thinking unless you set `thinking: {"type": "adaptive"}`. On Claude Opus 5, the same requests run with [thinking](https://platform.claude.com/docs/en/build-with-claude/thinking) on: the model decides when and how much to think on each turn, and the [effort parameter](https://platform.claude.com/docs/en/build-with-claude/effort) is the control for thinking depth. The wire value is unchanged; `thinking: {"type": "adaptive"}` remains valid and equivalent to the default.
41On Claude Opus 4.8, requests run without thinking unless you set `thinking: {"type": "adaptive"}`. On Claude Opus 5, the same requests run with [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking) on by default: the model decides when and how much to think on each turn, and the [effort parameter](https://platform.claude.com/docs/en/build-with-claude/effort) is the control for thinking depth. The wire value is unchanged; `thinking: {"type": "adaptive"}` remains valid and equivalent to the default.
4242
43Because `max_tokens` is a hard limit on total output (thinking plus response text), revisit it for workloads that ran without thinking on Claude Opus 4.8.
43This is a breaking change for code that ran without thinking on Claude Opus 4.8. A response can begin with one or more `thinking` blocks before the first `text` block, returned with an empty `thinking` field at the default `display: "omitted"`, so code that reads `content[0].text` or treats the first streamed content block as text must select content blocks by their `type` field instead. Tool-use loops must pass `thinking` blocks back complete and unmodified with their tool results; see [Preserving thinking blocks](https://platform.claude.com/docs/en/build-with-claude/thinking#preserving-thinking-blocks).
4444
45The API keeps the option to disable thinking, subject to the effort restriction below.
45Thinking tokens are billed as output tokens and count toward `max_tokens`, a hard limit on total output (thinking plus response text), so revisit `max_tokens` and re-baseline cost for workloads that ran without thinking on Claude Opus 4.8.
4646
47The API keeps the option to disable thinking, subject to the [effort restriction](https://platform.claude.com/docs/en/models/opus-5/whats-new-opus-5#disabling-thinking-requires-effort-high-or-below) on disabling it.
48
4749### Effort matters more
4850
4951Claude Opus 5 converts additional [effort](https://platform.claude.com/docs/en/build-with-claude/effort) into better results more reliably than any earlier Opus model, so the effort level you choose carries more weight. The full ladder is available: `low`, `medium`, `high`, `xhigh`, and `max`, with `max` as the top tier for the deepest possible reasoning. Start at the default, `high`, and adjust in either direction based on your evals: step down where quality holds to save tokens and latency, or step up for the most demanding work. When running at `xhigh` or `max` effort, set a large `max_tokens` so the model has room to think and act across subagents and tool calls.
from line 236
234236
235237### Disabling thinking requires effort `high` or below
236238
237On Claude Opus 5, `thinking: {"type": "disabled"}` is accepted only when the effort level is `high` or below. Setting `thinking: {"type": "disabled"}` with effort `xhigh` or `max` returns a 400 error. This rule is enforced on every request to Claude Opus 5 and later models. It is a breaking change from Claude Opus 4.8, where disabling thinking was independent of the effort level. If you disable thinking at high effort levels today, either keep thinking disabled and set effort to `high` or below, or keep the effort level and remove the `thinking` field.
239On Claude Opus 5, `thinking: {"type": "disabled"}` is accepted only when the effort level is `high` or below. Setting `thinking: {"type": "disabled"}` with effort `xhigh` or `max` returns a 400 error. This rule is enforced on every request to Claude Opus 5 and later models. It is a breaking change from Claude Opus 4.8, where disabling thinking was independent of the effort level. If your Claude Opus 4.8 requests disable thinking at effort `xhigh` or `max`, either keep thinking disabled and set effort to `high` or below, or keep the effort level and remove the `thinking` field.
238240
239241With thinking disabled, Claude Opus 5 can occasionally write a tool call into its text output instead of emitting a `tool_use` block, or include internal XML tags in its visible response. Where possible, keep thinking enabled and control token cost with lower effort levels; for integrations that must keep thinking disabled, see [Running with thinking disabled](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5#running-with-thinking-disabled) for prompting mitigations.
240242
241243### Model behavior differences
242244
243Beyond the API changes above, Claude Opus 5 behaves differently from Claude Opus 4.8 in ways you may notice without changing any code. Default user-facing responses and written deliverables run longer. In agentic sessions, the model narrates its progress to the user more often. In multi-agent frameworks, it delegates to subagents more readily. It also verifies its own work without being told to, so remove verification instructions carried over from earlier models ("include a final verification step," "use a subagent to verify"); they cause over-verification on Claude Opus 5. For prompting patterns that tune each of these behaviors, see [Prompting Claude Opus 5](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5).
245Beyond these API changes, Claude Opus 5 behaves differently from Claude Opus 4.8 in ways you may notice without changing any code. Default user-facing responses and written deliverables run longer. In agentic sessions, the model narrates its progress to the user more often. In multi-agent frameworks, it delegates to subagents more readily. It also verifies its own work without being told to, so remove verification instructions carried over from earlier models ("include a final verification step," "use a subagent to verify"); they cause over-verification on Claude Opus 5. For prompting patterns that tune each of these behaviors, see [Prompting Claude Opus 5](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5).
244246
245247## Capability improvements
246248
247Compared with Claude Opus 4.8, Claude Opus 5 is a step-change improvement rather than an incremental one, and it delivers frontier intelligence at half the cost of Claude Fable 5. The largest gains are in:
249Compared with Claude Opus 4.8, Claude Opus 5 is a step-change improvement rather than an incremental one, and it delivers frontier intelligence at half the cost of [Claude Fable 5](https://platform.claude.com/docs/en/models/fable-5/introducing-claude-fable-5-and-claude-mythos-5). The largest gains are in:
248250
249251* **Deep reasoning**, sustaining multistep analysis across long problem chains.
250252* **Agentic coding and long-horizon tasks**, staying on task across extended tool-use loops and completing multi-file features, larger refactors, and end-to-end feature work without leaving stubs or placeholders.
from line 262
260262
261263## Pricing
262264
263Claude Opus 5 is priced at $5 USD per million input tokens and $25 USD per million output tokens, unchanged from Claude Opus 4.8.
265Claude Opus 5 is priced at $5 USD per million input tokens and $25 USD per million output tokens, unchanged from Claude Opus 4.8. Because thinking is on by default and thinking tokens are billed as output tokens, a workload that ran without thinking on Claude Opus 4.8 can produce more output tokens per request at the same per-token rates; see [Cost control](https://platform.claude.com/docs/en/build-with-claude/thinking-steering-and-cost#cost-control).
264266
265267See [Pricing](https://platform.claude.com/docs/en/about-claude/pricing) for complete pricing, including batch processing, prompt caching, and fast mode rates.
266268
from line 318
316318 ```
317319</CodeGroup>
318320
319Then review the two [behavior changes](https://platform.claude.com/docs/en/models/opus-5/whats-new-opus-5#behavior-changes): thinking is on by default, and disabling thinking with effort `xhigh` or `max` returns a 400 error. See the [migration guide](https://platform.claude.com/docs/en/models/opus-5/migration-guide#migrating-from-claude-opus-4-8-to-claude-opus-5) for step-by-step instructions.
321Then review the two breaking changes under [Behavior changes](https://platform.claude.com/docs/en/models/opus-5/whats-new-opus-5#behavior-changes): thinking is on by default (responses can begin with `thinking` blocks, so select content blocks by `type`), and disabling thinking with effort `xhigh` or `max` returns a 400 error. See the [migration guide](https://platform.claude.com/docs/en/models/opus-5/migration-guide#migrating-from-claude-opus-4-8-to-claude-opus-5) for step-by-step instructions and the full checklist.
320322
321323## Next steps
322324
models/sonnet-5/migration-guide Changed · +11 / -3 lines
from line 20
2020
2121Claude Sonnet 5 offers the best combination of speed and intelligence in the Claude model family. It builds on Claude Sonnet 4.6.
2222
23Claude Sonnet 5 is a drop-in upgrade for Claude Sonnet 4.6, priced at $2/$10 USD per million input/output tokens; see [Pricing](https://platform.claude.com/docs/en/about-claude/pricing) for details. There are two breaking API changes for code already running on Claude Sonnet 4.6: manual extended thinking (`thinking: {type: "enabled", budget_tokens: N}`) and sampling parameters (`temperature`, `top_p`, `top_k`) set to non-default values are no longer accepted and return a 400 error. Use [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking) with the [effort parameter](https://platform.claude.com/docs/en/build-with-claude/effort) instead. Claude Sonnet 5 supports the same set of features as Claude Sonnet 4.6, including the [1M token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows), [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking), [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching), [batch processing](https://platform.claude.com/docs/en/build-with-claude/batch-processing), the [Files API](https://platform.claude.com/docs/en/build-with-claude/files), [PDF support](https://platform.claude.com/docs/en/build-with-claude/pdf-support), [vision](https://platform.claude.com/docs/en/build-with-claude/vision), and the full set of server-side and client-side [tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview). On the Claude API and Google Cloud, Claude Sonnet 5 also supports [computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) as the stable `computer_toolset_20260801` toolset and the [browser use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool) for tasks inside webpages, neither of which Claude Sonnet 4.6 supports; existing integrations on the earlier `computer_20251124` version continue to work unchanged on both models. To upgrade an existing integration, see [Migrate from `computer_20251124`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124). [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) is not available on Claude Sonnet 5. Claude Sonnet 5 also uses a new tokenizer.
23Claude Sonnet 5 is a drop-in upgrade for Claude Sonnet 4.6, priced at $2/$10 USD per million input/output tokens; see [Pricing](https://platform.claude.com/docs/en/about-claude/pricing) for details. There are two breaking API changes for code already running on Claude Sonnet 4.6. First, [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking) is on by default and manual extended thinking (`thinking: {type: "enabled", budget_tokens: N}`) returns a 400 error, so requests that ran without thinking can now return `thinking` blocks before the first `text` block and code that reads content by position must select content blocks by `type`. Second, sampling parameters (`temperature`, `top_p`, `top_k`) set to non-default values return a 400 error. Use adaptive thinking with the [effort parameter](https://platform.claude.com/docs/en/build-with-claude/effort) to control thinking depth. Claude Sonnet 5 supports the same set of features as Claude Sonnet 4.6, including the [1M token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows), [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking), [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching), [batch processing](https://platform.claude.com/docs/en/build-with-claude/batch-processing), the [Files API](https://platform.claude.com/docs/en/build-with-claude/files), [PDF support](https://platform.claude.com/docs/en/build-with-claude/pdf-support), [vision](https://platform.claude.com/docs/en/build-with-claude/vision), and the full set of server-side and client-side [tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview). On the Claude API and Google Cloud, Claude Sonnet 5 also supports [computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) as the stable `computer_toolset_20260801` toolset and the [browser use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool) for tasks inside webpages, neither of which Claude Sonnet 4.6 supports; existing integrations on the earlier `computer_20251124` version continue to work unchanged on both models. To upgrade an existing integration, see [Migrate from `computer_20251124`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124). [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) is not available on Claude Sonnet 5. Claude Sonnet 5 also uses a new tokenizer.
2424
2525## Migrating to Claude Sonnet 5 from Claude Sonnet 4.6
2626
from line 40
4040
4141Items 4 and 5 in the following list are breaking changes. `max_tokens` remains a hard limit on total output (thinking plus response text), so revisit it for workloads that ran without thinking on Claude Sonnet 4.6.
4242
431. **New tokenizer:** Claude Sonnet 5 uses a new tokenizer. The same input text produces approximately 30% more tokens than on Claude Sonnet 4.6. The exact increase depends on the content. Requests, responses, and streaming events keep the same shape, and no code changes are required, but anything you measure or budget in tokens shifts: `usage` fields and [token counting](https://platform.claude.com/docs/en/build-with-claude/token-counting) results for the same text are higher, the 1M token context window holds less text, and a `max_tokens` limit tuned for Claude Sonnet 4.6 may truncate equivalent output. Per-token pricing is lower ($2/$10 versus Claude Sonnet 4.6's $3/$15 per million input/output tokens), but the cost of an equivalent request does not drop in direct proportion. Re-run token counting against Claude Sonnet 5 rather than reusing counts measured against earlier models.
431. **New tokenizer:** Claude Sonnet 5 uses a new tokenizer. The same input text produces approximately 30% more tokens than on Claude Sonnet 4.6. The exact increase depends on the content. Requests, responses, and streaming events keep the same shape, and no code changes are required, but anything you measure or budget in tokens shifts: `usage` fields and [token counting](https://platform.claude.com/docs/en/build-with-claude/token-counting) results for the same text are higher, the 1M token context window holds less text, and a `max_tokens` limit tuned for Claude Sonnet 4.6 may truncate equivalent output. Per-token pricing is lower ($2/$10 USD versus Claude Sonnet 4.6's $3/$15 USD per million input/output tokens), but the cost of an equivalent request does not drop in direct proportion. Re-run token counting against Claude Sonnet 5 rather than reusing counts measured against earlier models.
4444
45452. **128k max output tokens (unchanged):** Claude Sonnet 5 supports up to 128k output tokens, the same as Claude Sonnet 4.6. Existing `max_tokens` values remain valid. Account for the new tokenizer when sizing them.
4646
from line 48
4848
49494. **Adaptive thinking on by default:** On Claude Sonnet 4.6, requests without a `thinking` field run without thinking; on Claude Sonnet 5, the same requests run with [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking). To turn thinking off, pass `thinking: {type: "disabled"}`. Manual extended thinking (`thinking: {type: "enabled", budget_tokens: N}`) is not supported and returns a 400 error. Use the [effort parameter](https://platform.claude.com/docs/en/build-with-claude/effort) (default `high`) to control thinking depth.
5050
51 With thinking on, a response can begin with one or more `thinking` blocks before the first `text` block, returned with an empty `thinking` field at the default `display: "omitted"`. Code that reads the reply by position, such as `content[0].text` or a stream handler that treats the first content block as text, must select content blocks by their `type` field instead, and tool-use loops must pass `thinking` blocks back complete and unmodified with their tool results (see [Preserving thinking blocks](https://platform.claude.com/docs/en/build-with-claude/thinking#preserving-thinking-blocks)). Thinking tokens are billed as output tokens even when the thinking text is not returned. If you used thinking on Claude Sonnet 4.6 and display the returned thinking text, note that `thinking.display` defaulted to `"summarized"` there and defaults to `"omitted"` on Claude Sonnet 5; set `display: "summarized"`, as the following example does, to keep receiving readable summaries (see [Controlling thinking display](https://platform.claude.com/docs/en/build-with-claude/thinking#controlling-thinking-display)).
52
5153 <Tabs>
5254 <Tab title="Claude Sonnet 5">
5355 <Note>
from line 554
552554* Re-run [token counting](https://platform.claude.com/docs/en/build-with-claude/token-counting) against Claude Sonnet 5. The new tokenizer produces approximately 30% more tokens for the same text, which can change per-request cost even though per-token pricing is lower. The exact increase depends on the content and workload shape.
553555* Revisit `max_tokens` limits sized close to your expected output length, and raise them up to the 128k maximum (unchanged from Claude Sonnet 4.6) where useful.
554556* Remove `thinking: {type: "enabled", budget_tokens: N}` configuration (returns a 400 error). Adaptive thinking is on by default; pass `{type: "disabled"}` to turn it off, or use the [effort parameter](https://platform.claude.com/docs/en/build-with-claude/effort) to control depth.
557* Update response parsing that reads content by position, such as `content[0].text`: with thinking on, `thinking` blocks arrive before `text` blocks. Select content blocks by `type` instead, and pass `thinking` blocks back unmodified in tool-use loops; modified blocks return a 400 error.
558* Verify any code that parses the `thinking` field treats it as display text only. `thinking.display` defaults to `"omitted"` on Claude Sonnet 5 (it defaulted to `"summarized"` on Claude Sonnet 4.6), so thinking blocks arrive with an empty `thinking` field; set `display: "summarized"` to receive readable summaries. See [Controlling thinking display](https://platform.claude.com/docs/en/build-with-claude/thinking#controlling-thinking-display).
555559* Remove `temperature`, `top_p`, and `top_k` parameters set to non-default values (they return a 400 error on Claude Sonnet 5).
556560* Add handling for `stop_reason: "refusal"` if your workload may touch cybersecurity topics.
557561* Re-baseline cost on your typical workload before production deployment.
from line 644
640644
6416451. **Thinking configuration:** Claude Haiku 4.5 supports manual extended thinking (`thinking: {type: "enabled", budget_tokens: N}`) and rejects `thinking: {type: "adaptive"}`. On Claude Sonnet 5, the support is reversed: adaptive thinking is on by default, and manual extended thinking returns a 400 error. Remove `thinking: {type: "enabled", budget_tokens: N}` configurations and rely on the default, or pass `thinking: {type: "disabled"}` to turn thinking off. `budget_tokens` has no direct replacement; use the [effort parameter](https://platform.claude.com/docs/en/build-with-claude/effort) to control thinking depth. Effort is not available on Claude Haiku 4.5 and defaults to `high` on Claude Sonnet 5.
642646
647 The response shape changes for both kinds of Claude Haiku 4.5 request. Requests that ran without extended thinking can now return one or more `thinking` blocks before the first `text` block, so code that reads the reply by position, such as `content[0].text`, must select content blocks by their `type` field instead, and tool-use loops must pass `thinking` blocks back complete and unmodified with their tool results (see [Preserving thinking blocks](https://platform.claude.com/docs/en/build-with-claude/thinking#preserving-thinking-blocks)). Requests that used extended thinking keep receiving `thinking` blocks, but `thinking.display` defaults to `"omitted"` on Claude Sonnet 5 rather than `"summarized"`, so those blocks arrive with an empty `thinking` field; set `display: "summarized"` to keep receiving readable summaries (see [Controlling thinking display](https://platform.claude.com/docs/en/build-with-claude/thinking#controlling-thinking-display)). Thinking tokens are billed as output tokens even when the thinking text is not returned.
648
6436492. **Sampling parameters removed:** `temperature` and `top_p` work on Claude Haiku 4.5 (one at a time, not both). On Claude Sonnet 5, setting `temperature`, `top_p`, or `top_k` to a non-default value returns a 400 error. Remove these parameters and use prompting to guide the model's behavior.
644650
6456513. **Assistant prefill removed:** Prefilling the assistant message works on Claude Haiku 4.5 but returns a 400 error on Claude Sonnet 5. Use [structured outputs](https://platform.claude.com/docs/en/build-with-claude/structured-outputs), system prompt instructions, or `output_config.format` instead.
from line 652
646652
6476534. **Larger context window and output:** Claude Sonnet 5 serves a 1M token context window by default, up from 200k tokens on Claude Haiku 4.5, and supports up to 128k output tokens, up from 64k. Claude Sonnet 5 also uses a different tokenizer, so re-run [token counting](https://platform.claude.com/docs/en/build-with-claude/token-counting) rather than reusing counts measured against Claude Haiku 4.5.
648654
6495. **Pricing:** Claude Haiku 4.5 is priced at $1/$5 per million input/output tokens. Claude Sonnet 5 is priced at $2/$10 per million input/output tokens. See [Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing).
6555. **Pricing:** Claude Haiku 4.5 is priced at $1/$5 USD per million input/output tokens. Claude Sonnet 5 is priced at $2/$10 USD per million input/output tokens. See [Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing).
650656
6516576. **Cybersecurity safeguards:** Claude Sonnet 5 has real-time cybersecurity safeguards. Requests that involve prohibited or high-risk cybersecurity topics may be refused, returned as a successful HTTP 200 response with `stop_reason: "refusal"`. See [Real-time cyber safeguards on Claude Opus and Sonnet](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet) for what the safeguards block and how legitimate security work can apply to the Cyber Verification Program.
652658
from line 660
654660
655661* Update the model name from `claude-haiku-4-5-20251001` (or the `claude-haiku-4-5` alias) to `claude-sonnet-5`.
656662* Remove `thinking: {type: "enabled", budget_tokens: N}` configuration (returns a 400 error). Adaptive thinking is on by default; pass `thinking: {type: "disabled"}` to preserve no-thinking behavior, and revisit `max_tokens` for workloads that ran without thinking.
663* Update response parsing that reads content by position, such as `content[0].text`: with thinking on, `thinking` blocks arrive before `text` blocks. Select content blocks by `type` instead, and pass `thinking` blocks back unmodified in tool-use loops; modified blocks return a 400 error.
664* If your UI displays thinking content, set `display: "summarized"`. `thinking.display` defaults to `"omitted"` on Claude Sonnet 5, so thinking blocks otherwise arrive with an empty `thinking` field. See [Controlling thinking display](https://platform.claude.com/docs/en/build-with-claude/thinking#controlling-thinking-display).
657665* Use the [effort parameter](https://platform.claude.com/docs/en/build-with-claude/effort) (default `high`) to control thinking depth and token spend; it is not available on Claude Haiku 4.5, so no existing setting carries over.
658666* Remove `temperature` and `top_p` settings (non-default values return a 400 error on Claude Sonnet 5).
659667* Remove any assistant-message prefills (they return a 400 error on Claude Sonnet 5).
release-notes/overview Changed · +5 / -3 lines
from line 14
1414
1515### August 27, 2026
1616
17* You can now create **personal keys** and **service account keys** in the Claude Console. They act as you or as a [service account](https://platform.claude.com/docs/en/manage-claude/workload-identity-federation#service-accounts), with the same permissions, and stop working when the linked account is removed from an organization. This lets organization admins more easily track usage for each account, and ensure key usage is legitimate. These API keys can be scoped to a specific workspace or [work on admin endpoints and across any workspace](https://platform.claude.com/docs/en/manage-claude/authentication#select-a-workspace) the account has access to. Workspace API keys remain supported as a legacy option. See [API keys](https://platform.claude.com/docs/en/manage-claude/authentication#api-keys) for more information.
17* In Python SDK 1.2.0, TypeScript SDK 0.122.0, Go SDK 1.68.0, Java SDK 2.59.0, Ruby SDK 1.67.0, and C# SDK 12.44.0, `client.beta.files` and `client.beta.skills` no longer send the `files-api-2025-04-14` and `skills-2025-10-02` beta headers and return the same shapes as `client.files` and `client.skills`. With this change, `client.beta.skills.delete()` deletes a Skill together with all of its versions, and the beta Messages type `BetaSkill` (the container Skill reference) is renamed `BetaContainerSkill`. Requests that still send the beta headers keep receiving the beta shapes. See [Migrate from `files-api-2025-04-14`](https://platform.claude.com/docs/en/build-with-claude/files#migrate-from-files-api-2025-04-14) and [Migrate from `skills-2025-10-02`](https://platform.claude.com/docs/en/build-with-claude/skills-guide#migrate-from-skills-2025-10-02).
1818
19- You can now create **personal keys** and **service account keys** in the Claude Console. They act as you or as a [service account](https://platform.claude.com/docs/en/manage-claude/workload-identity-federation#service-accounts), with the same permissions, and stop working when the linked account is removed from an organization. This lets organization admins more easily track usage for each account, and ensure key usage is legitimate. These API keys can be scoped to a specific workspace or [work on admin endpoints and across any workspace](https://platform.claude.com/docs/en/manage-claude/authentication#select-a-workspace) the account has access to. Workspace API keys remain supported as a legacy option. See [API keys](https://platform.claude.com/docs/en/manage-claude/authentication#api-keys) for more information.
20
1921### August 26, 2026
2022
2123* The [Compliance API](https://platform.claude.com/docs/en/manage-claude/compliance-api) session endpoints are out of beta for Cowork and Claude Code sessions. See [Retrieve session transcripts](https://platform.claude.com/docs/en/manage-claude/compliance-sessions).
from line 35
3335* The [computer use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) is out of beta on the Claude API as the `computer_toolset_20260801` toolset: no beta header, batch actions (several actions in one turn), `zoom` enabled by default, and per-member configuration through `configs`. Earlier beta versions remain available. Upgrading an existing integration changes the request shape and tool handling; see [Migrate from `computer_20251124`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124).
3436* We've launched the [browser use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool) (`browser_toolset_20260801`), a client toolset for driving a browser that your application hosts. It works inside a browser viewport rather than a whole desktop, reading the page itself (its accessibility tree, elements, forms, and tabs) and adding element references, form input, tab management, download reporting, and opt-in file upload on top of screenshot-and-click control.
3537* Both toolsets are available for Claude Fable 5, Claude Mythos 5, Claude Opus 5, Claude Sonnet 5, and Claude Opus 4.8 on the Claude API.
36* The [Files API](https://platform.claude.com/docs/en/build-with-claude/files) is out of beta on the Claude API. Requests to the `/v1/files` endpoints, and Messages API requests that reference an uploaded file, no longer require the `files-api-2025-04-14` beta header. Requests sent without the header use the current response format: [file expiration](https://platform.claude.com/docs/en/build-with-claude/files#file-expiration) (set `expires_in_seconds` when you upload a file; file objects report `expires_at`), and `page` and `next_page` [pagination](https://platform.claude.com/docs/en/api/overview#pagination) plus an `ids[]` filter when you [list files](https://platform.claude.com/docs/en/build-with-claude/files#list-files). `/v1/files` requests that still send the beta header keep working and return the previous response format.
37* [Agent Skills](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview) and the Skills API (`/v1/skills`) are out of beta on the Claude API. Requests no longer require the `skills-2025-10-02` beta header, including Messages API requests that load Skills through the `container` parameter. Requests that still send the header continue to work unchanged. See [Using Agent Skills with the API](https://platform.claude.com/docs/en/build-with-claude/skills-guide).
38* The [Files API](https://platform.claude.com/docs/en/build-with-claude/files) is out of beta on the Claude API. Requests to the `/v1/files` endpoints, and Messages API requests that reference an uploaded file, no longer require the `files-api-2025-04-14` beta header. Requests sent without the header use the current response format: [file expiration](https://platform.claude.com/docs/en/build-with-claude/files#file-expiration) (set `expires_in_seconds` when you upload a file; file objects report `expires_at`), and `page` and `next_page` [pagination](https://platform.claude.com/docs/en/api/overview#pagination) plus an `ids[]` filter when you [list files](https://platform.claude.com/docs/en/build-with-claude/files#list-files). `/v1/files` requests that still send the beta header keep working and return the previous response format. To move an existing integration off the header, see [Migrate from `files-api-2025-04-14`](https://platform.claude.com/docs/en/build-with-claude/files#migrate-from-files-api-2025-04-14).
39* [Agent Skills](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview) and the Skills API (`/v1/skills`) are out of beta on the Claude API. Requests no longer require the `skills-2025-10-02` beta header, including Messages API requests that load Skills through the `container` parameter. Requests that still send the header continue to work unchanged. See [Using Agent Skills with the API](https://platform.claude.com/docs/en/build-with-claude/skills-guide). To move an existing integration off the header, see [Migrate from `skills-2025-10-02`](https://platform.claude.com/docs/en/build-with-claude/skills-guide#migrate-from-skills-2025-10-02).
3840* The [Admin API](https://platform.claude.com/docs/en/api/admin) user-management endpoints for **Claude Enterprise** (claude.ai) organizations (members, invites, groups, and custom roles) are out of beta. The `anthropic-beta: ce-user-management-2026-07-13` header is no longer required on group and custom-role requests; requests that still send it are accepted unchanged. See [User management](https://platform.claude.com/docs/en/manage-claude/user-management).
3941* You can now restrict which sites a Claude Managed Agents agent's `web_search` and `web_fetch` tools can reach. Set `allowed_domains` or `blocked_domains` on the tool's entry in the `agent_toolset_20260401` `configs` array; `web_fetch` also accepts `max_content_tokens` and `web_search` accepts `user_location`. Each `configs` entry is identified by its `name` and typed by an optional `type`, and requests that pass only `name`, `enabled`, and `permission_policy` continue to work; in the typed SDKs, `configs` entries become per-tool types. See [Restrict web search and web fetch domains](https://platform.claude.com/docs/en/managed-agents/tools#restrict-web-search-and-web-fetch-domains).
4042* Claude Managed Agents sessions that run in a [self-hosted sandbox](https://platform.claude.com/docs/en/managed-agents/self-hosted-sandboxes) can now attach [memory stores](https://platform.claude.com/docs/en/managed-agents/memory). The Python, TypeScript, and Go SDK workers download each attached store into the sandbox at its `mount_path` and sync the agent's changes back to the store. See [Use memory stores](https://platform.claude.com/docs/en/managed-agents/self-hosted-sandboxes#use-memory-stores).
api/beta/files/delete Changed · +0 / -1 lines
from line 124
124124curl https://api.anthropic.com/v1/files/$FILE_ID \
125125 -X DELETE \
126126 -H 'anthropic-version: 2023-06-01' \
127 -H 'anthropic-beta: files-api-2025-04-14' \
128127 -H "X-Api-Key: $ANTHROPIC_API_KEY"
129128```
130129
api/beta/files/download Changed · +0 / -1 lines
from line 107
107107```bash
108108curl https://api.anthropic.com/v1/files/$FILE_ID/content \
109109 -H 'anthropic-version: 2023-06-01' \
110 -H 'anthropic-beta: files-api-2025-04-14' \
111110 -H "X-Api-Key: $ANTHROPIC_API_KEY"
112111```
113112
api/beta/messages/batches/results Changed · +1 / -1 lines
from line 148
148148
149149 format: date-time
150150
151 - `skills: array of BetaSkill or null`
151 - `skills: array of BetaContainerSkill or null`
152152
153153 Skills loaded in the container
154154