### Install Google Docs API Client Library for Python using Setuptools

Source: https://developers.google.com/workspace/docs/api/how-tos/libraries

Use Setuptools to install or upgrade the Google API client library for Python. This is an alternative to pip for managed installation.

```bash
easy_install --upgrade google-api-python-client
```

--------------------------------

### Install http-server Package

Source: https://developers.google.com/workspace/docs/api/quickstart/js

Install the http-server package using npm. This is a prerequisite for starting a local web server to run the sample.

```bash
npm install http-server

```

--------------------------------

### Install Google Docs API Client Library for Python Manually

Source: https://developers.google.com/workspace/docs/api/how-tos/libraries

Manually install the Python client library by downloading, unpacking, and running the setup script.

```bash
python setup.py install
```

--------------------------------

### Start Local Web Server

Source: https://developers.google.com/workspace/docs/api/quickstart/js

Start a local web server on port 8000 using npx. This command is used to serve the sample application from your working directory.

```bash
npx http-server -p 8000

```

--------------------------------

### Initialize Google Docs API Quickstart

Source: https://developers.google.com/workspace/docs/api/quickstart/python

The base code for the quickstart application, including necessary imports and the definition of read-only document scopes.

```python
import os.path

from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError

# If modifying these scopes, delete the file token.json.
SCOPES = ["https://www.googleapis.com/auth/documents.readonly"]
```

--------------------------------

### Install Google Docs API client libraries

Source: https://developers.google.com/workspace/docs/api/quickstart/nodejs

Install the necessary Google APIs and local authentication packages via npm to enable API interaction.

```bash
npm install googleapis@105 @google-cloud/local-auth@2.1.0 --save
```

--------------------------------

### Execute Python Quickstart Script

Source: https://developers.google.com/workspace/docs/api/quickstart/python

Command to run the authentication and API retrieval script from the terminal.

```bash
python3 quickstart.py
```

--------------------------------

### Install Google Docs API Client Library for Python using pip

Source: https://developers.google.com/workspace/docs/api/how-tos/libraries

Use pip to install or upgrade the Google API client library for Python. This is the preferred method for managed installation.

```bash
pip install --upgrade google-api-python-client
```

--------------------------------

### Run Gradle Project

Source: https://developers.google.com/workspace/docs/api/quickstart/java

Execute the Gradle build to run the Java quickstart application. This command initiates the application, which may prompt for authorization on the first run.

```bash
gradle run

```

--------------------------------

### Install Google Docs API Client Gem using RubyGems

Source: https://developers.google.com/workspace/docs/api/how-tos/libraries

Install the Google API Client Library for Ruby using RubyGems. You may need to prepend this command with `sudo`.

```bash
gem install google-api-client
```

--------------------------------

### Google Docs API Quickstart Implementation

Source: https://developers.google.com/workspace/docs/api/quickstart/go

A complete Go application that handles OAuth 2.0 authentication and retrieves a document title using the Google Docs API.

```go
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"

	"golang.org/x/oauth2"
	"golang.org/x/oauth2/google"
	"google.golang.org/api/docs/v1"
	"google.golang.org/api/option"
)

// Retrieves a token, saves the token, then returns the generated client.
func getClient(config *oauth2.Config) *http.Client {
	tokFile := "token.json"
	tok, err := tokenFromFile(tokFile)
	if err != nil {
		tok = getTokenFromWeb(config)
		saveToken(tokFile, tok)
	}
	return config.Client(context.Background(), tok)
}

// Requests a token from the web, then returns the retrieved token.
func getTokenFromWeb(config *oauth2.Config) *oauth2.Token {
	authURL := config.AuthCodeURL("state-token", oauth2.AccessTypeOffline)
	fmt.Printf("Go to the following link in your browser then type the "+
		"authorization code: \n%v\n", authURL)

	var authCode string
	if _, err := fmt.Scan(&authCode); err != nil {
		log.Fatalf("Unable to read authorization code: %v", err)
	}

	tok, err := config.Exchange(oauth2.NoContext, authCode)
	if err != nil {
		log.Fatalf("Unable to retrieve token from web: %v", err)
	}
	return tok
}

// Retrieves a token from a local file.
func tokenFromFile(file string) (*oauth2.Token, error) {
	f, err := os.Open(file)
	defer f.Close()
	if err != nil {
		return nil, err
	}
	tok := &oauth2.Token{}
	err = json.NewDecoder(f).Decode(tok)
	return tok, err
}

// Saves a token to a file path.
func saveToken(path string, token *oauth2.Token) {
	fmt.Printf("Saving credential file to: %s\n", path)
	f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
	defer f.Close()
	if err != nil {
		log.Fatalf("Unable to cache OAuth token: %v", err)
	}
	json.NewEncoder(f).Encode(token)
}

func main() {
	ctx := context.Background()
	b, err := os.ReadFile("credentials.json")
	if err != nil {
		log.Fatalf("Unable to read client secret file: %v", err)
	}

	// If modifying these scopes, delete your previously saved token.json.
	config, err := google.ConfigFromJSON(b, "https://www.googleapis.com/auth/documents.readonly")
	if err != nil {
		log.Fatalf("Unable to parse client secret file to config: %v", err)
	}
	client := getClient(config)

	srv, err := docs.NewService(ctx, option.WithHTTPClient(client))
	if err != nil {
		log.Fatalf("Unable to retrieve Docs client: %v", err)
	}

	// Prints the title of the requested doc:
	// https://docs.google.com/document/d/195j9eDD3ccgjQRttHhJPymLJUCOUjs-jmwTrekvdjFE/edit
	docId := "195j9eDD3ccgjQRttHhJPymLJUCOUjs-jmwTrekvdjFE"
	doc, err := srv.Documents.Get(docId).Do()
	if err != nil {
		log.Fatalf("Unable to retrieve data from document: %v", err)
	}
	fmt.Printf("The title of the doc is: %s\n", doc.Title)
}
```

--------------------------------

### Specific List Properties Example (kix.ussavk43dhsk)

Source: https://developers.google.com/workspace/docs/api/samples/output-json?hl=ar

This snippet shows a specific example of list properties configuration identified by 'kix.ussavk43dhsk', detailing various nesting levels with different glyph symbols and indentation.

```APIDOC
## Specific List Properties Example (kix.ussavk43dhsk)

### Description
This example demonstrates a specific list properties configuration, including multiple nesting levels with distinct bullet symbols and indentation settings.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **listProperties** (object) - Required - Contains the configuration for list properties.
  - **nestingLevels** (array) - Required - An array of objects, where each object defines the properties for a nesting level.
    - **bulletAlignment** (string) - Optional - Alignment of the bullet (e.g., "START", "END").
    - **glyphSymbol** (string) - Optional - The symbol used for the bullet point (e.g., "●", "○", "■").
    - **glyphFormat** (string) - Optional - The format string for the glyph.
    - **indentFirstLine** (object) - Optional - Specifies the indentation for the first line.
      - **magnitude** (number) - Required - The magnitude of the indentation.
      - **unit** (string) - Required - The unit of measurement (e.g., "PT").
    - **indentStart** (object) - Optional - Specifies the starting indentation.
      - **magnitude** (number) - Required - The magnitude of the indentation.
      - **unit** (string) - Required - The unit of measurement (e.g., "PT").
    - **textStyle** (object) - Optional - Defines the text style.
      - **underline** (boolean) - Optional - Whether the text should be underlined.
    - **startNumber** (integer) - Optional - The starting number for numbered lists.

### Request Example
```json
{
  "kix.ussavk43dhsk": {
    "listProperties": {
      "nestingLevels": [
        {
          "bulletAlignment": "START",
          "glyphSymbol": "●",
          "glyphFormat": "%0",
          "indentFirstLine": {
            "magnitude": 18.0,
            "unit": "PT"
          },
          "indentStart": {
            "magnitude": 36.0,
            "unit": "PT"
          },
          "textStyle": {
            "underline": false
          },
          "startNumber": 1
        },
        {
          "bulletAlignment": "START",
          "glyphSymbol": "○",
          "glyphFormat": "%1",
          "indentFirstLine": {
            "magnitude": 54.0,
            "unit": "PT"
          },
          "indentStart": {
            "magnitude": 72.0,
            "unit": "PT"
          },
          "textStyle": {
            "underline": false
          },
          "startNumber": 1
        },
        {
          "bulletAlignment": "START",
          "glyphSymbol": "■",
          "glyphFormat": "%2",
          "indentFirstLine": {
            "magnitude": 90.0,
            "unit": "PT"
          },
          "indentStart": {
            "magnitude": 108.0,
            "unit": "PT"
          },
          "textStyle": {
            "underline": false
          },
          "startNumber": 1
        }
      ]
    }
  }
}
```

### Response
#### Success Response (200)
- **kix.ussavk43dhsk** (object) - Contains the specific list properties configuration.

#### Response Example
```json
{
  "kix.ussavk43dhsk": {
    "listProperties": {
      "nestingLevels": [
        {
          "bulletAlignment": "START",
          "glyphSymbol": "●",
          "glyphFormat": "%0",
          "indentFirstLine": {
            "magnitude": 18.0,
            "unit": "PT"
          },
          "indentStart": {
            "magnitude": 36.0,
            "unit": "PT"
          },
          "textStyle": {
            "underline": false
          },
          "startNumber": 1
        },
        {
          "bulletAlignment": "START",
          "glyphSymbol": "○",
          "glyphFormat": "%1",
          "indentFirstLine": {
            "magnitude": 54.0,
            "unit": "PT"
          },
          "indentStart": {
            "magnitude": 72.0,
            "unit": "PT"
          },
          "textStyle": {
            "underline": false
          },
          "startNumber": 1
        },
        {
          "bulletAlignment": "START",
          "glyphSymbol": "■",
          "glyphFormat": "%2",
          "indentFirstLine": {
            "magnitude": 90.0,
            "unit": "PT"
          },
          "indentStart": {
            "magnitude": 108.0,
            "unit": "PT"
          },
          "textStyle": {
            "underline": false
          },
          "startNumber": 1
        }
      ]
    }
  }
}
```
```

--------------------------------

### Batch Update Request Example

Source: https://developers.google.com/workspace/docs/api/how-tos/batch

This example demonstrates how to construct a batch update request for the Google Docs API, including adding text and formatting it. All subrequests are applied atomically.

```json
{
  "requests": [
    {
      "insertText": {
        "location": {
          "index": 1
        },
        "text": "New bold text."
      }
    },
    {
      "updateTextStyle": {
        "textStyle": {
          "bold": true
        },
        "range": {
          "startIndex": 1,
          "endIndex": 19
        }
      }
    }
  ]
}
```

--------------------------------

### Initialize Google Docs API Quickstart

Source: https://developers.google.com/workspace/docs/api/quickstart/js

A complete HTML file containing the necessary scripts to authorize users and retrieve a document title. Replace the placeholder CLIENT_ID and API_KEY constants with your own credentials from the Google Cloud Console.

```html
<!DOCTYPE html>
<html>
  <head>
    <title>Google Docs API Quickstart</title>
    <meta charset="utf-8" />
  </head>
  <body>
    <p>Google Docs API Quickstart</p>

    <!--Add buttons to initiate auth sequence and sign out-->
    <button id="authorize_button" onclick="handleAuthClick()">Authorize</button>
    <button id="signout_button" onclick="handleSignoutClick()">Sign Out</button>

    <pre id="content" style="white-space: pre-wrap;"></pre>

    <script type="text/javascript">
      /* exported gapiLoaded */
      /* exported gisLoaded */
      /* exported handleAuthClick */
      /* exported handleSignoutClick */

      // TODO(developer): Set to client ID and API key from the Developer Console
      const CLIENT_ID = '<YOUR_CLIENT_ID>';
      const API_KEY = '<YOUR_API_KEY>';

      // Discovery doc URL for APIs used by the quickstart
      const DISCOVERY_DOC = 'https://docs.googleapis.com/$discovery/rest?version=v1';

      // Authorization scopes required by the API; multiple scopes can be
      // included, separated by spaces.
      const SCOPES = 'https://www.googleapis.com/auth/documents.readonly';

      let tokenClient;
      let gapiInited = false;
      let gisInited = false;

      document.getElementById('authorize_button').style.visibility = 'hidden';
      document.getElementById('signout_button').style.visibility = 'hidden';

      /**
       * Callback after api.js is loaded.
       */
      function gapiLoaded() {
        gapi.load('client', initializeGapiClient);
      }

      /**
       * Callback after the API client is loaded. Loads the
       * discovery doc to initialize the API.
       */
      async function initializeGapiClient() {
        await gapi.client.init({
          apiKey: API_KEY,
          discoveryDocs: [DISCOVERY_DOC],
        });
        gapiInited = true;
        maybeEnableButtons();
      }

      /**
       * Callback after Google Identity Services are loaded.
       */
      function gisLoaded() {
        tokenClient = google.accounts.oauth2.initTokenClient({
          client_id: CLIENT_ID,
          scope: SCOPES,
          callback: '', // defined later
        });
        gisInited = true;
        maybeEnableButtons();
      }

      /**
       * Enables user interaction after all libraries are loaded.
       */
      function maybeEnableButtons() {
        if (gapiInited && gisInited) {
          document.getElementById('authorize_button').style.visibility = 'visible';
        }
      }

      /**
       *  Sign in the user upon button click.
       */
      function handleAuthClick() {
        tokenClient.callback = async (resp) => {
          if (resp.error !== undefined) {
            throw (resp);
          }
          document.getElementById('signout_button').style.visibility = 'visible';
          document.getElementById('authorize_button').innerText = 'Refresh';
          await printDocTitle();
        };

        if (gapi.client.getToken() === null) {
          // Prompt the user to select a Google Account and ask for consent to share their data
          // when establishing a new session.
          tokenClient.requestAccessToken({prompt: 'consent'});
        } else {
          // Skip display of account chooser and consent dialog for an existing session.
          tokenClient.requestAccessToken({prompt: ''});
        }
      }

      /**
       *  Sign out the user upon button click.
       */
      function handleSignoutClick() {
        const token = gapi.client.getToken();
        if (token !== null) {
          google.accounts.oauth2.revoke(token.access_token);
          gapi.client.setToken('');
          document.getElementById('content').innerText = '';
          document.getElementById('authorize_button').innerText = 'Authorize';
          document.getElementById('signout_button').style.visibility = 'hidden';
        }
      }

      /**
       * Prints the title of a sample doc:
       * https://docs.google.com/document/d/195j9eDD3ccgjQRttHhJPymLJUCOUjs-jmwTrekvdjFE/edit
       */
      async function printDocTitle() {
        try {
          const response = await gapi.client.docs.documents.get({
            documentId: '195j9eDD3ccgjQRttHhJPymLJUCOUjs-jmwTrekvdjFE',
          });
          const doc = response.result;
          const output = `Document ${doc.title} successfully found.\n`;
          document.getElementById('content').innerText = output;
        } catch (err) {
          document.getElementById('content').innerText = err.message;
          return;
        }
      }
    </script>
    <script async defer src="https://apis.google.com/js/api.js" onload="gapiLoaded()"></script>
    <script async defer src="https://accounts.google.com/gsi/client" onload="gisLoaded()"></script>
  </body>
</html>
```

--------------------------------

### Google Docs API Authentication and Setup - Python

Source: https://developers.google.com/workspace/docs/api/samples/extract-text?hl=bn

Provides necessary imports and boilerplate for authenticating with the Google Docs API and setting up the service client. Includes scopes for reading and writing documents.

```python
# Copyright 2026 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""
Recursively extracts the text from a Google Doc.
"""
import os.path

import googleapiclient.discovery as discovery
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.errors import HttpError

```

--------------------------------

### Java Quickstart for Google Docs API

Source: https://developers.google.com/workspace/docs/api/quickstart/java

This Java code sets up authentication and retrieves the title of a Google Document using the Docs API. Ensure you have a 'credentials.json' file and the necessary dependencies.

```java
import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.extensions.java6.auth.oauth2.AuthorizationCodeInstalledApp;
import com.google.api.client.extensions.jetty.auth.oauth2.LocalServerReceiver;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow;
import com.google.api.client.googleapis.auth.oauth2.GoogleClientSecrets;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.client.util.store.FileDataStoreFactory;
import com.google.api.services.docs.v1.Docs;
import com.google.api.services.docs.v1.DocsScopes;
import com.google.api.services.docs.v1.model.Document;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.GeneralSecurityException;
import java.util.Collections;
import java.util.List;

/* class to demonstrate use of Docs get documents API */
public class DocsQuickstart {
  /**
   * Application name.
   */
  private static final String APPLICATION_NAME = "Google Docs API Java Quickstart";
  /**
   * Global instance of the JSON factory.
   */
  private static final JsonFactory JSON_FACTORY = GsonFactory.getDefaultInstance();
  /**
   * Directory to store authorization tokens for this application.
   */
  private static final String TOKENS_DIRECTORY_PATH = "tokens";
  private static final String DOCUMENT_ID = "195j9eDD3ccgjQRttHhJPymLJUCOUjs-jmwTrekvdjFE";

  /**
   * Global instance of the scopes required by this quickstart.
   * If modifying these scopes, delete your previously saved tokens/ folder.
   */
  private static final List<String> SCOPES =
      Collections.singletonList(DocsScopes.DOCUMENTS_READONLY);
  private static final String CREDENTIALS_FILE_PATH = "/credentials.json";

  /**
   * Creates an authorized Credential object.
   *
   * @param HTTP_TRANSPORT The network HTTP Transport.
   * @return An authorized Credential object.
   * @throws IOException If the credentials.json file cannot be found.
   */
  private static Credential getCredentials(final NetHttpTransport HTTP_TRANSPORT)
      throws IOException {
    // Load client secrets.
    InputStream in = DocsQuickstart.class.getResourceAsStream(CREDENTIALS_FILE_PATH);
    if (in == null) {
      throw new FileNotFoundException("Resource not found: " + CREDENTIALS_FILE_PATH);
    }
    GoogleClientSecrets clientSecrets = 
        GoogleClientSecrets.load(JSON_FACTORY, new InputStreamReader(in));

    // Build flow and trigger user authorization request.
    GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(
        HTTP_TRANSPORT, JSON_FACTORY, clientSecrets, SCOPES) 
        .setDataStoreFactory(new FileDataStoreFactory(new java.io.File(TOKENS_DIRECTORY_PATH)))
        .setAccessType("offline")
        .build();
    LocalServerReceiver receiver = new LocalServerReceiver.Builder().setPort(8888).build();
    Credential credential = new AuthorizationCodeInstalledApp(flow, receiver).authorize("user");
    //returns an authorized Credential object.
    return credential;
  }

  public static void main(String... args) throws IOException, GeneralSecurityException {
    // Build a new authorized API client service.
    final NetHttpTransport HTTP_TRANSPORT = GoogleNetHttpTransport.newTrustedTransport();
    Docs service = new Docs.Builder(HTTP_TRANSPORT, JSON_FACTORY, getCredentials(HTTP_TRANSPORT))
        .setApplicationName(APPLICATION_NAME)
        .build();

    // Prints the title of the requested doc:
    // https://docs.google.com/document/d/195j9eDD3ccgjQRttHhJPymLJUCOUjs-jmwTrekvdjFE/edit
    Document response = service.documents().get(DOCUMENT_ID).execute();
    String title = response.getTitle();

    System.out.printf("The title of the doc is: %s\n", title);
  }
}
```

--------------------------------

### Full Resource Response Example (Demo API)

Source: https://developers.google.com/workspace/docs/api/how-tos/performance

This JSON structure represents a full response from a generic API, containing various fields including nested objects and arrays. It is shown for comparison with partial responses.

```json
{
  "kind": "demo",
  ...
  "items": [
  {
    "title": "First title",
    "comment": "First comment.",
    "characteristics": {
      "length": "short",
      "accuracy": "high",
      "followers": ["Jo", "Will"],
    },
    "status": "active",
    ...
  },
  {
    "title": "Second title",
    "comment": "Second comment.",
    "characteristics": {
      "length": "long",
      "accuracy": "medium"
      "followers": [ ],
    },
    "status": "pending",
    ...
  },
  ...
  ]
}
```

--------------------------------

### Partial Resource Response Example (Demo API)

Source: https://developers.google.com/workspace/docs/api/how-tos/performance

This JSON structure represents a partial response from a generic API, containing only the fields specified in the 'fields' parameter of the request. It includes the 'kind' and a reduced set of 'items' data.

```json
{
  "kind": "demo",
  "items": [{
    "title": "First title",
    "characteristics": {
      "length": "short"
    }
  }, {
    "title": "Second title",
    "characteristics": {
      "length": "long"
    }
  },
  ...
  ]
}
```

--------------------------------

### Run the Sample Application

Source: https://developers.google.com/workspace/docs/api/quickstart/go

Command to execute the Go application.

```bash
go run quickstart.go
```

--------------------------------

### Initialize Go Project Environment

Source: https://developers.google.com/workspace/docs/api/quickstart/go

Commands to create a directory, initialize a module, and fetch required Google API and OAuth2 dependencies.

```bash
mkdir quickstart
```

```bash
cd quickstart
```

```bash
go mod init quickstart
```

```bash
go get google.golang.org/api/docs/v1
go get golang.org/x/oauth2/google
```

--------------------------------

### GET /v1/documents

Source: https://developers.google.com/workspace/docs/api/reference/rest/v1/documents

Gets the latest version of the specified document.

```APIDOC
## GET /v1/documents

### Description
Gets the latest version of the specified document.

### Method
GET

### Endpoint
/v1/documents/{documentId}
```

--------------------------------

### Initialize Gradle Project Structure

Source: https://developers.google.com/workspace/docs/api/quickstart/java

Creates the base directory structure and initializes a basic Gradle project.

```bash
gradle init --type basic
mkdir -p src/main/java src/main/resources
```

--------------------------------

### Get and Print Google Document (Python)

Source: https://developers.google.com/workspace/docs/api/samples/output-json?hl=fa

Performs a 'get' request to the Google Docs API to retrieve a document and prints the result as formatted JSON. Ensure DOCUMENT_ID is set correctly.

```python
# Do a document "get" request and print the results as formatted JSON
result = service.documents().get(documentId=DOCUMENT_ID, includeTabsContent=True).execute()
print(json.dumps(result, indent=4, sort_keys=True))
```

--------------------------------

### GET /documents.get

Source: https://developers.google.com/workspace/docs/api/concepts/request-response?hl=es-419

Retrieves the full content and formatting of a specified document.

```APIDOC
## GET documents.get

### Description
Returns a full instance of the specified document. Note: This method cannot be used for published documents.

### Method
GET

### Endpoint
documents.get

### Parameters
#### Path Parameters
- **documentId** (string) - Required - The ID of the document to retrieve.
```

--------------------------------

### GET /documents/{documentId}

Source: https://developers.google.com/workspace/docs/api/reference/rest/v1/documents/get

Retrieves the latest version of the specified Google Document.

```APIDOC
## GET https://docs.googleapis.com/v1/documents/{documentId}

### Description
Gets the latest version of the specified document.

### Method
GET

### Endpoint
https://docs.googleapis.com/v1/documents/{documentId}

### Parameters
#### Path Parameters
- **documentId** (string) - Required - The ID of the document to retrieve.

#### Query Parameters
- **suggestionsViewMode** (enum) - Optional - The suggestions view mode to apply to the document.
- **includeTabsContent** (boolean) - Optional - Whether to populate the Document.tabs field instead of the text content fields.

### Response
#### Success Response (200)
- **Document** (object) - An instance of the Document resource.
```

--------------------------------

### Initialize Gradle Project

Source: https://developers.google.com/workspace/docs/api/quickstart/java?hl=zh-cn

Creates a new basic Gradle project and necessary directories for the Java application.

```bash
gradle init --type basic
mkdir -p src/main/java src/main/resources 

```

--------------------------------

### Installazione delle librerie client Google

Source: https://developers.google.com/workspace/docs/api/quickstart/python?hl=it

Comando per installare le librerie necessarie per l'interazione con le API di Google Workspace tramite Python.

```bash
python3 -m pip install --upgrade google-api-python-client google-auth-httplib2 google-auth-oauthlib
```

--------------------------------

### SectionType Enum

Source: https://developers.google.com/workspace/docs/api/reference/rest/v1/documents

Represents how the start of the current section is positioned relative to the previous section.

```APIDOC
## SectionType

### Description
Represents how the start of the current section is positioned relative to the previous section.

### Enums
- `SECTION_TYPE_UNSPECIFIED`: The section type is unspecified.
- `CONTINUOUS`: The section starts immediately after the last paragraph of the previous section.
- `NEXT_PAGE`: The section starts on the next page.
```

--------------------------------

### Get document without suggestions

Source: https://developers.google.com/workspace/docs/api/how-tos/suggestions

Retrieve a document with suggestions rejected using the PREVIEW_WITHOUT_SUGGESTIONS mode.

```java
final string SUGGEST_MODE = "PREVIEW_WITHOUT_SUGGESTIONS";
Document doc =
    service
        .documents()
        .get(DOCUMENT_ID)
        .setIncludeTabsContent(true)
        .setSuggestionsViewMode(SUGGEST_MODE)
        .execute();
```

```python
SUGGEST_MODE = "PREVIEW_WITHOUT_SUGGESTIONS"
result = (
  service.documents()
  .get(
      documentId=DOCUMENT_ID,
      includeTabsContent=True,
      suggestionsViewMode=SUGGEST_MODE,
  )
  .execute()
)
```

--------------------------------

### Initialize Google Docs API in JavaScript

Source: https://developers.google.com/workspace/docs/api/samples/output-json?hl=de

Sets up the Google API client library for browser-based interaction. Requires valid Client ID and API Key configuration.

```html
<!DOCTYPE html>
<html>
  <head>
    <title>
      Docs API Extract Body
    </title>
    <meta charset="utf-8"/>
  </head>
  <body>
    <p>
      Docs API Extract Body
    </p>
    <!--Add buttons to initiate auth sequence and sign out-->
    <button id="authorize-button" style="display: none;">Authorize</button>
    <button id="signout-button" style="display: none;">Sign Out</button>
    <pre id="content"></pre>

    <script type="text/javascript">
      // Client ID and API key from the Developer Console
      var CLIENT_ID = '<YOUR_CLIENT_ID>'
      var API_KEY = '<YOUR_API_KEY>';

      // Array of API discovery doc URLs for APIs used by the sample
      var DISCOVERY_DOCS = [
        'https://docs.googleapis.com/$discovery/rest?version=v1'];

      // Authorization scopes required by the API; multiple scopes can be
      // included, separated by spaces.
      var SCOPES = "https://www.googleapis.com/auth/documents.readonly";

      var authorizeButton = document.getElementById('authorize-button');
      var signoutButton = document.getElementById('signout-button');

      /**
       *  On load, called to load the auth2 library and API client library.
       */
      function handleClientLoad() {
        gapi.load('client:auth2', initClient);
      }

      /**
       *  Initializes the API client library and sets up sign-in state
       *  listeners.
       */
      function initClient() {
        gapi.client.init({
```

--------------------------------

### TableRange Definition

Source: https://developers.google.com/workspace/docs/api/reference/rest/v1/documents/request

Defines a subset of a table, specifying a starting cell and spans for rows and columns.

```APIDOC
## TableRange

### Description
A table range represents a reference to a subset of a table. The cells specified by a table range do not necessarily form a rectangle.

### JSON Representation
```json
{
  "tableCellLocation": {
    "object": "TableCellLocation"
  },
  "rowSpan": "integer",
  "columnSpan": "integer"
}
```

### Fields
- **tableCellLocation** (object) - The cell location where the table range starts.
- **rowSpan** (integer) - The row span of the table range.
- **columnSpan** (integer) - The column span of the table range.
```

--------------------------------

### Delete a table from a document

Source: https://developers.google.com/workspace/docs/api/how-tos/tables

Deletes a table by identifying its start and end indexes within the document content.

```java
// Delete a table that was inserted at the start of the body of the first tab.
// (The table is the second element in the body:
//  documentTab.getBody().getContent().get(2).)

Document document = docsService.documents().get(<var>DOCUMENT_ID</var>).setIncludeTabsContent(true).execute();
String tabId = document.getTabs()[0].getTabProperties().getTabId();
DocumentTab documentTab = document.getTabs()[0].getDocumentTab();
StructuralElement table = documentTab.getBody().getContent().get(2);

List<Request> requests = new ArrayList<>();
requests.add(
    new Request()
        .setDeleteContentRange(
            new DeleteContentRangeRequest()
                .setRange(
                    new Range()
                        .setStartIndex(table.getStartIndex())
                        .setEndIndex(table.getEndIndex())
                        .setTabId(tabId))));

BatchUpdateDocumentRequest body =
    new BatchUpdateDocumentRequest().setRequests(requests);
BatchUpdateDocumentResponse response =
    docsService.documents().batchUpdate(<var>DOCUMENT_ID</var>, body).execute();
```

```python
# Delete a table that was inserted at the start of the body of the first tab.
# (The table is the second element in the body: ['body']['content'][2].)

document = service.documents().get(documentId=DOCUMENT_ID, includeTabsContent=True).execute()
tab_id = document['tabs'][0]['tabProperties']['tabId']
document_tab = document['tabs'][0]['documentTab']
table = document_tab['body']['content'][2]

requests = [{
    'deleteContentRange': {
      'range': {
        'segmentId': '',
        'startIndex': table['startIndex'],
        'endIndex':   table['endIndex'],
        'tabId': tab_id
      }
    },
}
]

result = service.documents().batchUpdate(documentId=<var>DOCUMENT_ID</var>, body={'requests': requests}).execute()
```

--------------------------------

### GET /documents/{documentId}

Source: https://developers.google.com/workspace/docs/api/how-tos/suggestions?hl=it

Retrieves the content of a document, potentially including unresolved suggestions. The SuggestionsViewMode parameter controls how these suggestions are displayed.

```APIDOC
## GET /documents/{documentId}

### Description
Retrieves the content of a document, potentially including unresolved suggestions. The SuggestionsViewMode parameter controls how these suggestions are displayed.

### Method
GET

### Endpoint
/documents/{documentId}

### Query Parameters
- **SuggestionsViewMode** (string) - Optional - Controls how suggestions are displayed. Possible values: `SUGGESTIONS_INLINE`, `PREVIEW_WITH_ACCEPTED`, `PREVIEW_WITHOUT_DELETED`.

### Response
#### Success Response (200)
- **documentContent** (object) - The content of the document, with suggestions rendered according to SuggestionsViewMode.

#### Response Example
{
  "documentContent": "{\"title\": \"Example Document\", \"body\": { \"content\": [ { \"paragraph\": { \"elements\": [ { \"textRun\": { \"content\": \"This is the document content with suggestions.\" } } ] } } ] } }"
}
```

--------------------------------

### Initialize Google API Client and Handle Authentication (JavaScript)

Source: https://developers.google.com/workspace/docs/api/samples/output-json?hl=fa

Initializes the Google API client with API key, client ID, discovery documents, and scopes. It also sets up listeners for sign-in state changes and button click handlers for authorization and sign-out.

```javascript
gapi.client.init({
        apiKey: API_KEY,
        clientId: CLIENT_ID,
        discoveryDocs: DISCOVERY_DOCS,
        scope: SCOPES
      }).then(function () {
        // Listen for sign-in state changes.
        gapi.auth2.getAuthInstance().isSignedIn.listen(updateSigninStatus);

      // Handle the initial sign-in state.
        updateSigninStatus(gapi.auth2.getAuthInstance().isSignedIn.get());
        authorizeButton.onclick = handleAuthClick;
        signoutButton.onclick = handleSignoutClick;
        });
      }
```

--------------------------------

### Range Object

Source: https://developers.google.com/workspace/docs/api/reference/rest/v1/documents

Represents a contiguous range of text within a document. It includes segment ID, start and end indices, and tab ID.

```APIDOC
## Range Object

### Description
Specifies a contiguous range of text.

### JSON Representation
```json
{
  "segmentId": "string",
  "startIndex": "integer",
  "endIndex": "integer",
  "tabId": "string"
}
```

### Fields
- **segmentId** (string): The ID of the header, footer, or footnote that this range is contained in. An empty segment ID signifies the document's body.
- **startIndex** (integer): The zero-based start index of this range, in UTF-16 code units. Must be provided.
- **endIndex** (integer): The zero-based end index of this range, exclusive, in UTF-16 code units. Must be provided.
- **tabId** (string): The tab that contains this range. When omitted, the request applies to the first tab. Behavior varies based on the number of tabs in the document.
```

--------------------------------

### Initialize Google Docs API in JavaScript

Source: https://developers.google.com/workspace/docs/api/samples/output-json?hl=bn

Configures the Google API client and sets up authentication listeners for user sign-in state changes.

```javascript
gapi.client.init({
        apiKey: API_KEY,
        clientId: CLIENT_ID,
        discoveryDocs: DISCOVERY_DOCS,
        scope: SCOPES
      }).then(function () {
        // Listen for sign-in state changes.
        gapi.auth2.getAuthInstance().isSignedIn.listen(updateSigninStatus);

      // Handle the initial sign-in state.
        updateSigninStatus(gapi.auth2.getAuthInstance().isSignedIn.get());
        authorizeButton.onclick = handleAuthClick;
        signoutButton.onclick = handleSignoutClick;
        });
      }

      /**
       *  Called when the signed in status changes, to update the UI
       *  appropriately. After a sign-in, the API is called.
       */
      function updateSigninStatus(isSignedIn) {
        if (isSignedIn) {
        authorizeButton.style.display = 'none';
        signoutButton.style.display = 'block';
        printDocBody();
        } else {
        authorizeButton.style.display = 'block';
        signoutButton.style.display = 'none';
        }
      }

      /**
       *  Sign in the user upon button click.
       */
      function handleAuthClick(event) {
        gapi.auth2.getAuthInstance().signIn();
      }

      /**
       *  Sign out the user upon button click.
       */
      function handleSignoutClick(event) {
        gapi.auth2.getAuthInstance().signOut();
      }

      /**
       * Append a pre element to the body containing the given message
       * as its text node. Used to display the results of the API call.
       *
       * @param {string} message Text to be placed in pre element.
       */
      function appendPre(message) {
        var pre = document.getElementById('content');
        var textContent = document.createTextNode(message + '\n');
        pre.appendChild(textContent);
      }

      /**
       * Prints the JSON body of a document.
       */
      function printDocBody() {
        gapi.client.docs.documents.get({
        documentId: '<var>DOCUMENT_ID</var>',
        includeTabsContent: true
      }).then(function(response) {
        var doc = response.result;
        appendPre(JSON.stringify(doc.body, null, 4));
      },function(response) {
        appendPre('Error: ' + response.result.error.message);
        });
      }
```

--------------------------------

### Range Object

Source: https://developers.google.com/workspace/docs/api/reference/rest/v1/documents?hl=bn

Represents a contiguous range of text within a document. It includes start and end indices, and can be associated with a specific tab or segment.

```APIDOC
## Range Object

### Description
Specifies a contiguous range of text.

### JSON Representation
```json
{
  "segmentId": string,
  "startIndex": integer,
  "endIndex": integer,
  "tabId": string
}
```

### Fields
- **segmentId** (string) - The ID of the header, footer, or footnote that this range is contained in. An empty segment ID signifies the document's body.
- **startIndex** (integer) - The zero-based start index of this range, in UTF-16 code units. In all current uses, a start index must be provided. This field is an Int32Value in order to accommodate future use cases with open-ended ranges.
- **endIndex** (integer) - The zero-based end index of this range, exclusive, in UTF-16 code units. In all current uses, an end index must be provided. This field is an Int32Value in order to accommodate future use cases with open-ended ranges.
- **tabId** (string) - The tab that contains this range. When omitted, the request applies to the first tab. In a document containing a single tab: If provided, must match the singular tab's ID. If omitted, the request applies to the singular tab. In a document containing multiple tabs: If provided, the request applies to the specified tab. If omitted, the request applies to the first tab in the document.
```

--------------------------------

### Get Mail Merge Data from Source

Source: https://developers.google.com/workspace/docs/api/samples/mail-merge?hl=id

Retrieves mail merge data from either a 'sheets' or 'text' source. Raises a ValueError for unsupported sources.

```python
def get_data(source):
  """Gets mail merge data from chosen data source."""
  try:
    if source not in {"sheets", "text"}:
      raise ValueError(
          f"ERROR: unsupported source {source}; choose from {SOURCES}"
      )
    return SAFE_DISPATCH[source]()
  except HttpError as error:
    print(f"An error occurred: {error}")
    return error
```

--------------------------------

### Get Document with Suggestions Previewed (Python)

Source: https://developers.google.com/workspace/docs/api/how-tos/suggestions?hl=pt-br

This Python snippet fetches a document with suggestions hidden by setting SuggestionsViewMode to PREVIEW_WITHOUT_SUGGESTIONS. The service object must be authenticated.

```python
SUGGEST_MODE = "PREVIEW_WITHOUT_SUGGESTIONS"
result =
  service.documents()
  .get(
      documentId=DOCUMENT_ID,
      includeTabsContent=True,
      suggestionsViewMode=SUGGEST_MODE,
  )
  .execute()
```

--------------------------------

### Initialize Google API Client and Authentication

Source: https://developers.google.com/workspace/docs/api/samples/output-json?hl=es-419

Handles client initialization and user sign-in status changes. Listens for sign-in state changes and updates the UI accordingly. Requires `gapi` to be loaded.

```javascript
function initClient() {
        gapi.client.init({
        apiKey: API_KEY,
        clientId: CLIENT_ID,
        discoveryDocs: DISCOVERY_DOCS,
        scope: SCOPES
      }).then(function () {
        // Listen for sign-in state changes.
        gapi.auth2.getAuthInstance().isSignedIn.listen(updateSigninStatus);

      // Handle the initial sign-in state.
        updateSigninStatus(gapi.auth2.getAuthInstance().isSignedIn.get());
        authorizeButton.onclick = handleAuthClick;
        signoutButton.onclick = handleSignoutClick;
        });
      }
```

--------------------------------

### Initialize Google Docs API in Browser

Source: https://developers.google.com/workspace/docs/api/samples/output-json?hl=id

Sets up the HTML structure and JavaScript client library initialization for browser-based Google Docs API authentication.

```html
<!DOCTYPE html>
<html>
  <head>
    <title>
      Docs API Extract Body
    </title>
    <meta charset="utf-8"/>
  </head>
  <body>
    <p>
      Docs API Extract Body
    </p>
    <!--Add buttons to initiate auth sequence and sign out-->
    <button id="authorize-button" style="display: none;">Authorize</button>
    <button id="signout-button" style="display: none;">Sign Out</button>
    <pre id="content"></pre>

    <script type="text/javascript">
      // Client ID and API key from the Developer Console
      var CLIENT_ID = '<YOUR_CLIENT_ID>'
      var API_KEY = '<YOUR_API_KEY>';

      // Array of API discovery doc URLs for APIs used by the sample
      var DISCOVERY_DOCS = [
        'https://docs.googleapis.com/$discovery/rest?version=v1'];

      // Authorization scopes required by the API; multiple scopes can be
      // included, separated by spaces.
      var SCOPES = "https://www.googleapis.com/auth/documents.readonly";

      var authorizeButton = document.getElementById('authorize-button');
      var signoutButton = document.getElementById('signout-button');

      /**
       *  On load, called to load the auth2 library and API client library.
       */
      function handleClientLoad() {
        gapi.load('client:auth2', initClient);
      }

      /**
       *  Initializes the API client library and sets up sign-in state
       *  listeners.
       */
      function initClient() {
```

--------------------------------

### Initialize Google Docs API imports in Python

Source: https://developers.google.com/workspace/docs/api/samples/extract-text?hl=de

Required imports and setup for recursively extracting text from a Google Doc using the Python client library.

```python
# Copyright 2026 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""
Recursively extracts the text from a Google Doc.
"""
import os.path

import googleapiclient.discovery as discovery
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.errors import HttpError
```

--------------------------------

### Main method to fetch and print Google Doc content

Source: https://developers.google.com/workspace/docs/api/samples/extract-text?hl=zh-cn

Builds the Google Docs API client, fetches a document by ID, retrieves all tabs, and prints the text content from each tab's body. Ensure DOCUMENT_ID is set and authentication is configured.

```java
public static void main(String... args) throws IOException, GeneralSecurityException {
    // Build a new authorized API client service.
    final NetHttpTransport HTTP_TRANSPORT = GoogleNetHttpTransport.newTrustedTransport();
    Docs service =
        new Docs.Builder(HTTP_TRANSPORT, JSON_FACTORY, getCredentials(HTTP_TRANSPORT))
            .setApplicationName(APPLICATION_NAME)
            .build();

    // Fetch the document with all of the tabs populated, including any nested
    // child tabs.
    Document doc =
        service.documents().get(DOCUMENT_ID).setIncludeTabsContent(true).execute();
    List allTabs = getAllTabs(doc);

    // Print the text from each tab in the document.
    for (Tab tab: allTabs) {
      // Get the DocumentTab from the generic Tab.
      DocumentTab documentTab = tab.getDocumentTab();
      System.out.println(
          readStructuralElements(documentTab.getBody().getContent()));
    }
  }
```

--------------------------------

### Initialize Google API Client Library (JavaScript)

Source: https://developers.google.com/workspace/docs/api/samples/output-json

This JavaScript snippet shows how to initialize the Google API client library, including setting up authentication scopes and loading necessary discovery documents. This is typically called on page load to prepare for API interactions.

```JavaScript
<!DOCTYPE html>
<html>
  <head>
    <title>
      Docs API Extract Body
    </title>
    <meta charset="utf-8"/>
  </head>
  <body>
    <p>
      Docs API Extract Body
    </p>
    <!--Add buttons to initiate auth sequence and sign out-->
    <button id="authorize-button" style="display: none;">Authorize</button>
    <button id="signout-button" style="display: none;">Sign Out</button>
    <pre id="content"></pre>

    <script type="text/javascript">
      // Client ID and API key from the Developer Console
      var CLIENT_ID = '<YOUR_CLIENT_ID>'
      var API_KEY = '<YOUR_API_KEY>';

      // Array of API discovery doc URLs for APIs used by the sample
      var DISCOVERY_DOCS = [
        'https://docs.googleapis.com/$discovery/rest?version=v1'];

      // Authorization scopes required by the API; multiple scopes can be
      // included, separated by spaces.
      var SCOPES = "https://www.googleapis.com/auth/documents.readonly";

      var authorizeButton = document.getElementById('authorize-button');
      var signoutButton = document.getElementById('signout-button');

      /**
       *  On load, called to load the auth2 library and API client library.
       */
      function handleClientLoad() {
        gapi.load('client:auth2', initClient);
      }

      /**
       *  Initializes the API client library and sets up sign-in state
       *  listeners.
       */
      function initClient() {
        gapi.client.init({

```