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

# Duplicate a workbook

POST https://api.sigmacomputing.com/v2/workbooks/{workbookId}/copy
Content-Type: application/json

This endpoint lets you duplicate an existing workbook. The workbook copy can be placed in a different folder from the original workbook, potentially with a different name and description. This is useful for creating workbook templates or backups.

### Usage notes

* The `workbookId` in the URL specifies the original workbook to be copied. Retrieve the **workbookId** by calling the [/v2/workbooks](https://help.sigmacomputing.com/reference/list-workbooks) endpoint.
* The `destinationFolderId` in the request body specifies where to place the new workbook.

  * To use the "My Documents" folder for a specific user as the destination folder, call the [/v2/members/\{memberId}](https://help.sigmacomputing.com/reference/get-member) endpoint and use the `homeFolderId` included in the response.
  * Retrieve the **folderId** of all folders by calling the [/v2/files](https://help.sigmacomputing.com/reference/list-files) endpoint and reviewing the `id` field in the response for files with a `type` of `folder`.

### Usage scenarios

* **Reuse**: Use an existing workbook as a baseline for a "one-off" purpose instead of a template.
* **Template creation**: Create a copy of a workbook to serve as a template for future projects.
* **Backup**: Make a backup of a workbook before making significant changes. [Version tagging](https://help.sigmacomputing.com/docs/version-tagging) is also a useful way to accomplish this.

### Best practices

* Always verify that the destination folder has the correct permissions set to avoid access issues.
* When using as a template, ensure that all data connections are correctly configured to prevent data leaks or errors.

### Copying bookmarks

* Set `copyBookmarks` to `all` to copy every saved view (formerly "bookmarks") applied to the source workbook. This is available to admins only.
* Set `copyBookmarks` to `accessible` to copy personal saved views and those shared with the user initiating the operation.
* Ownership of all copied bookmarks transfers to the user initiating the copy operation.

Reference: https://help.sigmacomputing.com/reference/copy-workbook

## Authentication

- OAuth2 — send the obtained token as `Authorization: Bearer <token>`

## Servers

- `https://api.sigmacomputing.com` (Server for GCP (US) hosted organizations, default)
- `https://api.sa.gcp.sigmacomputing.com` (Server for GCP (KSA) hosted organizations)
- `https://aws-api.sigmacomputing.com` (Server for AWS US (West) hosted organizations)
- `https://api.us-a.aws.sigmacomputing.com` (Server for AWS US (East) hosted organizations)
- `https://api.ca.aws.sigmacomputing.com` (Server for AWS Canada hosted organizations)
- `https://api.eu.aws.sigmacomputing.com` (Server for AWS Europe hosted organizations)
- `https://api.au.aws.sigmacomputing.com` (Server for AWS Australia and APAC hosted organizations)
- `https://api.uk.aws.sigmacomputing.com` (Server for AWS UK hosted organizations)
- `https://api.us.azure.sigmacomputing.com` (Server for Azure US hosted organizations)
- `https://api.eu.azure.sigmacomputing.com` (Server for Azure Europe hosted organizations)
- `https://api.ca.azure.sigmacomputing.com` (Server for Azure Canada hosted organizations)
- `https://api.uk.azure.sigmacomputing.com` (Server for Azure United Kingdom hosted organizations)
- `https://api.au.azure.sigmacomputing.com` (Server for Azure Australia hosted organizations)

## Request

### Path parameters

- `workbookId` (string, required)

### Body (application/json)

- `destinationFolderId` (string, required) — ID of the folder in which to place the copied workbook.
- `name` (string, required) — Name for the copied workbook as it appears in Sigma.
- `description` (string, optional) — A description for the new workbook.
- `copyBookmarks` (enum, optional) — If set to `all` (available to admins only), every saved view (bookmark) applied to the workbook is copied. If set to `accessible`, only personal saved views and those shared with the user initiating the operation are copied. Ownership of all saved views in the duplicate workbook transfers to the user initiating the operation. If not set, saved views are not copied.
  - Allowed values: `all`, `accessible`

## Response

### 200

The response body.

- `workbookId` (string, required) — Unique identifier of the workbook.
- `workbookUrlId` (string, required)
- `name` (string, required)
- `url` (string, required)
- `path` (string, required)
- `latestVersion` (double, required)
- `ownerId` (string, required)
- `createdBy` (string, required) — The identifier of the user who created this object.
- `updatedBy` (string, required) — The identifier of the user or process that last updated this object.
- `createdAt` (datetime, required) — When the object was created.
- `updatedAt` (datetime, required) — When the object was last updated.
- `isArchived` (boolean, optional)
- `tags` (list of object, optional)
  - `versionTagId` (string, required) — Unique identifier of the tag.
  - `name` (string, required)
  - `sourceWorkbookVersion` (double, required)
  - `taggedWorkbookId` (string, required) — Unique identifier of the tagged workbook.
  - `workbookTaggedAt` (datetime, required)
- `description` (string, optional)
- `taggedSourceUrlId` (string, optional) — For a workbook deployed to a tenant organization by a deployment policy with a version tag, the `urlId` of the original source workbook in the parent organization. Only present when `includeTaggedSourceUrlId=true` is included in the request.

## Examples

**Request**

```json
{
  "destinationFolderId": "string",
  "name": "string"
}
```

**Response**

```json
{
  "workbookId": "string",
  "workbookUrlId": "string",
  "name": "string",
  "url": "string",
  "path": "string",
  "latestVersion": 1.1,
  "ownerId": "string",
  "createdBy": "string",
  "updatedBy": "string",
  "createdAt": "2024-01-15T09:30:00Z",
  "updatedAt": "2024-01-15T09:30:00Z",
  "isArchived": true,
  "tags": [
    {
      "versionTagId": "string",
      "name": "string",
      "sourceWorkbookVersion": 1.1,
      "taggedWorkbookId": "string",
      "workbookTaggedAt": "2024-01-15T09:30:00Z"
    }
  ],
  "description": "string",
  "taggedSourceUrlId": "string"
}
```

**SDK Code**

```python
import requests

url = "https://api.sigmacomputing.com/v2/workbooks/workbookId/copy"

payload = {
    "destinationFolderId": "string",
    "name": "string"
}
headers = {
    "Authorization": "<token>.",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.sigmacomputing.com/v2/workbooks/workbookId/copy';
const options = {
  method: 'POST',
  headers: {Authorization: '<token>.', 'Content-Type': 'application/json'},
  body: '{"destinationFolderId":"string","name":"string"}'
};

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

```go
package main

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

func main() {

	url := "https://api.sigmacomputing.com/v2/workbooks/workbookId/copy"

	payload := strings.NewReader("{\n  \"destinationFolderId\": \"string\",\n  \"name\": \"string\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "<token>.")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.sigmacomputing.com/v2/workbooks/workbookId/copy")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = '<token>.'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"destinationFolderId\": \"string\",\n  \"name\": \"string\"\n}"

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

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.sigmacomputing.com/v2/workbooks/workbookId/copy")
  .header("Authorization", "<token>.")
  .header("Content-Type", "application/json")
  .body("{\n  \"destinationFolderId\": \"string\",\n  \"name\": \"string\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.sigmacomputing.com/v2/workbooks/workbookId/copy', [
  'body' => '{
  "destinationFolderId": "string",
  "name": "string"
}',
  'headers' => [
    'Authorization' => '<token>.',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.sigmacomputing.com/v2/workbooks/workbookId/copy");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "<token>.");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"destinationFolderId\": \"string\",\n  \"name\": \"string\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "<token>.",
  "Content-Type": "application/json"
]
let parameters = [
  "destinationFolderId": "string",
  "name": "string"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.sigmacomputing.com/v2/workbooks/workbookId/copy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()
```