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

# List Bulk Send Jobs

GET https://api.hellosign.com/v3/bulk_send_job/list

Returns a list of BulkSendJob that you can access.

Reference: https://developers.hellosign.com/api/bulk-send-job/list

## Authentication

- `Authorization` header (basic auth, required) — Your API key can be used to make calls to the Dropbox Sign API. See [Authentication](/api/reference/authentication) for more information. ✅ Supported by Try it console (calls sent in `test_mode` only).
- `Authorization` header (bearer token, required) — You can use an Access Token issued through an OAuth flow to send calls to the Dropbox Sign API from your app. The access scopes required by this endpoint are listed in the gray box above. See [Authentication](/api/reference/authentication) for more information. ❌ **Not supported** by Try it console.

## Request

### Query parameters

- `page` (integer, optional, default: 1) — Which page number of the BulkSendJob List to return. Defaults to `1`.
- `page_size` (integer, optional, default: 20) — Number of objects to be returned per page. Must be between `1` and `100`. Default is 20.

## Response

### 200

successful operation

- `bulk_send_jobs` (list of object, required) — Contains a list of BulkSendJobs that the API caller has access to.
  - `bulk_send_job_id` (string, optional, nullable) — The id of the BulkSendJob.
  - `total` (integer, optional) — The total amount of Signature Requests queued for sending.
  - `is_creator` (boolean, optional) — True if you are the owner of this BulkSendJob, false if it's been shared with you by a team member.
  - `created_at` (integer, optional) — Time that the BulkSendJob was created.
- `list_info` (object, required) — Contains pagination information about the data returned.
  - `num_pages` (integer, optional) — Total number of pages available.
  - `num_results` (integer, optional, nullable) — Total number of objects available.
  - `page` (integer, optional) — Number of the page being returned.
  - `page_size` (integer, optional) — Objects returned per page.
- `warnings` (list of object, optional) — A list of warnings.
  - `warning_msg` (string, required) — Warning message
  - `warning_name` (string, required) — Warning name

## Examples

**Response**

```json
{
  "bulk_send_jobs": [
    {
      "bulk_send_job_id": "fef03f144d9384737a98ff2ca6c1fd9d7bc2239a",
      "total": 250,
      "is_creator": false,
      "created_at": 1532740871
    },
    {
      "bulk_send_job_id": "6e683bc0369ba3d5b6f43c2c22a8031dbf6bd174",
      "total": 1,
      "is_creator": true,
      "created_at": 1532640962
    }
  ],
  "list_info": {
    "num_pages": 1,
    "num_results": 2,
    "page": 1,
    "page_size": 20
  }
}
```

**SDK Code**

```php PHP
<?php

namespace Dropbox\SignSandbox;

require_once __DIR__ . '/../vendor/autoload.php';

use SplFileObject;
use Dropbox;

$config = Dropbox\Sign\Configuration::getDefaultConfiguration();
$config->setUsername("YOUR_API_KEY");
// $config->setAccessToken("YOUR_ACCESS_TOKEN");

try {
    $response = (new Dropbox\Sign\Api\BulkSendJobApi(config: $config))->bulkSendJobList(
        page: 1,
        page_size: 20,
    );

    print_r($response);
} catch (Dropbox\Sign\ApiException $e) {
    echo "Exception when calling BulkSendJobApi#bulkSendJobList: {$e->getMessage()}";
}

```

```csharp C#
using System;
using System.Collections.Generic;
using System.IO;
using System.Text.Json;

using Dropbox.Sign.Api;
using Dropbox.Sign.Client;
using Dropbox.Sign.Model;

namespace Dropbox.SignSandbox;

public class BulkSendJobListExample
{
    public static void Run()
    {
        var config = new Configuration();
        config.Username = "YOUR_API_KEY";
        // config.AccessToken = "YOUR_ACCESS_TOKEN";

        try
        {
            var response = new BulkSendJobApi(config).BulkSendJobList(
                page: 1,
                pageSize: 20
            );

            Console.WriteLine(response);
        }
        catch (ApiException e)
        {
            Console.WriteLine("Exception when calling BulkSendJobApi#BulkSendJobList: " + e.Message);
            Console.WriteLine("Status Code: " + e.ErrorCode);
            Console.WriteLine(e.StackTrace);
        }
    }
}

```

```typescript TypeScript
import * as fs from 'fs';
import api from "@dropbox/sign"
import models from "@dropbox/sign"

const apiCaller = new api.BulkSendJobApi();
apiCaller.username = "YOUR_API_KEY";
// apiCaller.accessToken = "YOUR_ACCESS_TOKEN";

apiCaller.bulkSendJobList(
  1, // page
  20, // pageSize
).then(response => {
  console.log(response.body);
}).catch(error => {
  console.log("Exception when calling BulkSendJobApi#bulkSendJobList:");
  console.log(error.body);
});

```

```java Java
package com.dropbox.sign_sandbox;

import com.dropbox.sign.ApiException;
import com.dropbox.sign.Configuration;
import com.dropbox.sign.api.*;
import com.dropbox.sign.auth.*;
import com.dropbox.sign.JSON;
import com.dropbox.sign.model.*;

import java.io.File;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.OffsetDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class BulkSendJobListExample
{
    public static void main(String[] args)
    {
        var config = Configuration.getDefaultApiClient();
        ((HttpBasicAuth) config.getAuthentication("api_key")).setUsername("YOUR_API_KEY");
        // ((HttpBearerAuth) config.getAuthentication("oauth2")).setBearerToken("YOUR_ACCESS_TOKEN");

        try
        {
            var response = new BulkSendJobApi(config).bulkSendJobList(
                1, // page
                20 // pageSize
            );

            System.out.println(response);
        } catch (ApiException e) {
            System.err.println("Exception when calling BulkSendJobApi#bulkSendJobList");
            System.err.println("Status code: " + e.getCode());
            System.err.println("Reason: " + e.getResponseBody());
            System.err.println("Response headers: " + e.getResponseHeaders());
            e.printStackTrace();
        }
    }
}

```

```ruby Ruby
require "json"
require "dropbox-sign"

Dropbox::Sign.configure do |config|
    config.username = "YOUR_API_KEY"
    # config.access_token = "YOUR_ACCESS_TOKEN"
end

begin
    response = Dropbox::Sign::BulkSendJobApi.new.bulk_send_job_list(
        {
            page: 1,
            page_size: 20,
        },
    )

    p response
rescue Dropbox::Sign::ApiError => e
    puts "Exception when calling BulkSendJobApi#bulk_send_job_list: #{e}"
end

```

```python Python
import json
from datetime import date, datetime
from pprint import pprint

from dropbox_sign import ApiClient, ApiException, Configuration, api, models

configuration = Configuration(
    username="YOUR_API_KEY",
    # access_token="YOUR_ACCESS_TOKEN",
)

with ApiClient(configuration) as api_client:
    try:
        response = api.BulkSendJobApi(api_client).bulk_send_job_list(
            page=1,
            page_size=20,
        )

        pprint(response)
    except ApiException as e:
        print("Exception when calling BulkSendJobApi#bulk_send_job_list: %s\n" % e)

```

```go Bulk Send Job List
package main

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

func main() {

	url := "https://api.hellosign.com/v3/bulk_send_job/list"

	req, _ := http.NewRequest("GET", url, nil)

	req.SetBasicAuth("<apiKey>", "")

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

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

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

}
```

```swift Bulk Send Job List
import Foundation

let credentials = Data("<apiKey>:".utf8).base64EncodedString()

let headers = ["Authorization": "Basic \(credentials)"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hellosign.com/v3/bulk_send_job/list")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()
```