> 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.

# Download Files as Data Uri

GET https://api.hellosign.com/v3/signature_request/files_as_data_uri/{signature_request_id}

Obtain a copy of the current documents specified by the `signature_request_id` parameter. Returns a JSON object with a `data_uri` representing the base64 encoded file (PDFs only).

If the files are currently being prepared, a status code of `409` will be returned instead.

Reference: https://developers.hellosign.com/api/signature-request/files-as-data-uri

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: Dropbox Sign API
  version: 1.0.0
paths:
  /signature_request/files_as_data_uri/{signature_request_id}:
    get:
      operationId: filesAsDataUri
      summary: Download Files as Data Uri
      description: >-
        Obtain a copy of the current documents specified by the
        `signature_request_id` parameter. Returns a JSON object with a
        `data_uri` representing the base64 encoded file (PDFs only).


        If the files are currently being prepared, a status code of `409` will
        be returned instead.
      tags:
        - signatureRequest
      parameters:
        - name: signature_request_id
          in: path
          description: The id of the SignatureRequest to retrieve.
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: >
            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).            
          required: true
          schema:
            type: string
      responses:
        '200':
          description: successful operation
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FileResponseDataUri'
        '400':
          description: failed_operation
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
servers:
  - url: https://api.hellosign.com/v3
    description: https://api.hellosign.com/v3
components:
  schemas:
    FileResponseDataUri:
      type: object
      properties:
        data_uri:
          type: string
          description: File as base64 encoded string.
      required:
        - data_uri
      title: FileResponseDataUri
    ErrorResponseError:
      type: object
      properties:
        error_msg:
          type: string
          description: Message describing an error.
        error_path:
          type: string
          description: Path at which an error occurred.
        error_name:
          type: string
          description: >-
            Name of the error. See the `x-error-codes` catalog in openapi file
            for a complete list of possible error codes with detailed
            information including HTTP status codes, causes, remediation steps,
            and retry guidance.
      required:
        - error_msg
        - error_name
      description: Contains information about an error that occurred.
      title: ErrorResponseError
    ErrorResponse:
      type: object
      properties:
        error:
          $ref: '#/components/schemas/ErrorResponseError'
      required:
        - error
      title: ErrorResponse
  securitySchemes:
    Basic:
      type: http
      scheme: basic
      description: >
        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).            
    Bearer:
      type: http
      scheme: bearer
      description: >
        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.

```

## Examples



**Response**

```json
{
  "data_uri": "string",
  "expires_at": 1458605123,
  "file_url": "https://s3.amazonaws.com/hellofax_uploads/super_groups/2016/03/18/9aba07a585d7e223b4f137c8981c5e5892893c00/merged-completed.pdf?AWSAccessKeyId=AKIAJWEWDFQHQMBECJZA&Expires=1452868903&Signature=M%2FNDS%2BQre8xjPvzm7fHf%2BjO8Zbc%3D"
}
```

**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\SignatureRequestApi(config: $config))->signatureRequestFilesAsDataUri(
        signature_request_id: "fa5c8a0b0f492d768749333ad6fcc214c111e967",
    );

    print_r($response);
} catch (Dropbox\Sign\ApiException $e) {
    echo "Exception when calling SignatureRequestApi#signatureRequestFilesAsDataUri: {$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 SignatureRequestFilesAsDataUriExample
{
    public static void Run()
    {
        var config = new Configuration();
        config.Username = "YOUR_API_KEY";
        // config.AccessToken = "YOUR_ACCESS_TOKEN";

        try
        {
            var response = new SignatureRequestApi(config).SignatureRequestFilesAsDataUri(
                signatureRequestId: "fa5c8a0b0f492d768749333ad6fcc214c111e967"
            );

            Console.WriteLine(response);
        }
        catch (ApiException e)
        {
            Console.WriteLine("Exception when calling SignatureRequestApi#SignatureRequestFilesAsDataUri: " + 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.SignatureRequestApi();
apiCaller.username = "YOUR_API_KEY";
// apiCaller.accessToken = "YOUR_ACCESS_TOKEN";

apiCaller.signatureRequestFilesAsDataUri(
  "fa5c8a0b0f492d768749333ad6fcc214c111e967", // signatureRequestId
).then(response => {
  console.log(response.body);
}).catch(error => {
  console.log("Exception when calling SignatureRequestApi#signatureRequestFilesAsDataUri:");
  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 SignatureRequestFilesAsDataUriExample
{
    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 SignatureRequestApi(config).signatureRequestFilesAsDataUri(
                "fa5c8a0b0f492d768749333ad6fcc214c111e967" // signatureRequestId
            );

            System.out.println(response);
        } catch (ApiException e) {
            System.err.println("Exception when calling SignatureRequestApi#signatureRequestFilesAsDataUri");
            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::SignatureRequestApi.new.signature_request_files_as_data_uri(
        "fa5c8a0b0f492d768749333ad6fcc214c111e967", # signature_request_id
    )

    p response
rescue Dropbox::Sign::ApiError => e
    puts "Exception when calling SignatureRequestApi#signature_request_files_as_data_uri: #{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.SignatureRequestApi(api_client).signature_request_files_as_data_uri(
            signature_request_id="fa5c8a0b0f492d768749333ad6fcc214c111e967",
        )

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

```

```go Signature Requests Files
package main

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

func main() {

	url := "https://api.hellosign.com/v3/signature_request/files_as_data_uri/fa5c8a0b0f492d768749333ad6fcc214c111e967"

	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 Signature Requests Files
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hellosign.com/v3/signature_request/files_as_data_uri/fa5c8a0b0f492d768749333ad6fcc214c111e967")! 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()
```