Se usó la API de Cloud Translation para traducir esta página.

Subir datos de archivos

La API de Google Drive te permite subir datos de archivos cuando creas o actualizas File. Para obtener información sobre cómo crear un File solo de metadatos, consulta Crea archivos.

Puedes realizar 3 tipos de cargas:

Carga simple (uploadType=media): Usa este tipo de carga para transferir un archivo multimedia pequeño (5 MB o menos) sin proporcionar metadatos. Para realizar una carga simple, consulta Realiza una carga simple.
Carga multiparte (uploadType=multipart): Usa este tipo de carga para transferir un archivo pequeño (5 MB o menos) junto con los metadatos que describen el archivo, en una sola solicitud. Para realizar una carga multiparte, consulta Realiza una carga multiparte.
Carga reanudable (uploadType=resumable): Usa este tipo de carga para archivos grandes (más de 5 MB) y cuando haya una alta probabilidad de interrupción de red, como cuando se crea un archivo desde una app para dispositivos móviles. Las cargas reanudables también son una buena opción para la mayoría de las aplicaciones, ya que también funcionan para archivos pequeños a un costo mínimo de una solicitud HTTP adicional por carga. Para realizar una carga reanudable, consulta Realiza una carga reanudable.

Las bibliotecas cliente de la API de Google implementan, al menos, uno de estos tipos de cargas. Consulta la documentación sobre bibliotecas cliente para obtener más información sobre cómo usar cada uno de los tipos.

Comparación entre el uso de `PATCH` y de `PUT`

Como recordatorio, el verbo HTTP PATCH admite una actualización parcial de los recursos de archivo, mientras que el verbo HTTP PUT admite el reemplazo completo de recursos. Ten en cuenta que PUT puede introducir cambios rotundos cuando se agrega un campo nuevo a un recurso existente.

Cuando subes un recurso de archivo, usa los siguientes lineamientos:

Usa el verbo HTTP documentado en la referencia de API para la solicitud inicial de una carga reanudable o para la única solicitud de una carga simple o multiparte.
Usa PUT para todas las solicitudes posteriores de una carga reanudable una vez que haya comenzado la solicitud. Estas solicitudes suben contenido sin importar el método que se llame.

Realiza una carga simple.

Para realizar una carga simple, usa el método files.create con uploadType=media.

A continuación, se muestra cómo realizar una carga simple:

HTTP

Crea una solicitud POST para el URI /upload del método con el parámetro de búsqueda uploadType=media:

POST https://www.googleapis.com/upload/drive/v3/files?uploadType=media
Agrega los datos del archivo al cuerpo de la solicitud.
Agrega estos encabezados HTTP:
- Content-Type. Se establece en el tipo de medio MIME del objeto que se sube.
- Content-Length. Se establece en la cantidad de bytes que subes. Si usas la codificación de transferencia fragmentada, este encabezado no es obligatorio.
Envía la solicitud. Si la solicitud se realiza correctamente, el servidor muestra el código de estado HTTP 200 OK junto con los metadatos del archivo. {HTTP}.

Cuando realizas una carga simple, se crean metadatos básicos y algunos atributos se infieren del archivo, como el tipo MIME o modifiedTime. Puedes usar una carga simple en los casos en que tengas archivos pequeños y los metadatos de archivos no sean importantes.

Cómo realizar una carga multiparte

Una solicitud de carga multiparte te permite subir metadatos y datos en la misma solicitud. Usa esta opción si los datos que envías son lo suficientemente pequeños para volver a subirlos, en su totalidad, si la conexión falla.

Para realizar una carga multiparte, usa el método files.create con uploadType=multipart.

A continuación, se muestra cómo realizar una carga multiparte:

Java

drive/snippets/drive_v3/src/main/java/UploadBasic.java

Ver en GitHub

import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.FileContent;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.drive.Drive;
import com.google.api.services.drive.DriveScopes;
import com.google.api.services.drive.model.File;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Arrays;

/* Class to demonstrate use of Drive insert file API */
public class UploadBasic {

  /**
   * Upload new file.
   *
   * @return Inserted file metadata if successful, {@code null} otherwise.
   * @throws IOException if service account credentials file not found.
   */
  public static String uploadBasic() throws IOException {
    // Load pre-authorized user credentials from the environment.
    // TODO(developer) - See https://developers.google.com/identity for
    // guides on implementing OAuth2 for your application.
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Arrays.asList(DriveScopes.DRIVE_FILE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Build a new authorized API client service.
    Drive service = new Drive.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Drive samples")
        .build();
    // Upload file photo.jpg on drive.
    File fileMetadata = new File();
    fileMetadata.setName("photo.jpg");
    // File's content.
    java.io.File filePath = new java.io.File("files/photo.jpg");
    // Specify media type and file-path for file.
    FileContent mediaContent = new FileContent("image/jpeg", filePath);
    try {
      File file = service.files().create(fileMetadata, mediaContent)
          .setFields("id")
          .execute();
      System.out.println("File ID: " + file.getId());
      return file.getId();
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      System.err.println("Unable to upload file: " + e.getDetails());
      throw e;
    }
  }
}

Python

drive/snippets/drive-v3/file_snippet/upload_basic.py

Ver en GitHub

from __future__ import print_function

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from googleapiclient.http import MediaFileUpload


def upload_basic():
    """Insert new file.
    Returns : Id's of the file uploaded

    Load pre-authorized user credentials from the environment.
    TODO(developer) - See https://developers.google.com/identity
    for guides on implementing OAuth2 for the application.
    """
    creds, _ = google.auth.default()

    try:
        # create drive api client
        service = build('drive', 'v3', credentials=creds)

        file_metadata = {'name': 'download.jpeg'}
        media = MediaFileUpload('download.jpeg',
                                mimetype='image/jpeg')
        # pylint: disable=maybe-no-member
        file = service.files().create(body=file_metadata, media_body=media,
                                      fields='id').execute()
        print(F'File ID: {file.get("id")}')

    except HttpError as error:
        print(F'An error occurred: {error}')
        file = None

    return file.get('id')


if __name__ == '__main__':
    upload_basic()

Node.js

drive/snippets/drive_v3/file_snippets/upload_basic.js

Ver en GitHub

/**
 * Insert new file.
 * @return{obj} file Id
 * */
async function uploadBasic() {
  const fs = require('fs');
  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');

  // Get credentials and build service
  // TODO (developer) - Use appropriate auth mechanism for your app
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });
  const service = google.drive({version: 'v3', auth});
  const requestBody = {
    name: 'photo.jpg',
    fields: 'id',
  };
  const media = {
    mimeType: 'image/jpeg',
    body: fs.createReadStream('files/photo.jpg'),
  };
  try {
    const file = await service.files.create({
      requestBody,
      media: media,
    });
    console.log('File Id:', file.data.id);
    return file.data.id;
  } catch (err) {
    // TODO(developer) - Handle error
    throw err;
  }
}

PHP

drive/snippets/drive_v3/src/DriveUploadBasic.php (en inglés)

Ver en GitHub

use Google\Client;
use Google\Service\Drive;
# TODO - PHP client currently chokes on fetching start page token
function uploadBasic()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $fileMetadata = new Drive\DriveFile(array(
        'name' => 'photo.jpg'));
        $content = file_get_contents('../files/photo.jpg');
        $file = $driveService->files->create($fileMetadata, array(
            'data' => $content,
            'mimeType' => 'image/jpeg',
            'uploadType' => 'multipart',
            'fields' => 'id'));
        printf("File ID: %s\n", $file->id);
        return $file->id;
    } catch(Exception $e) {
        echo "Error Message: ".$e;
    } 

}

.NET

drive/snippets/drive_v3/DriveV3Snippets/UploadBasic.cs (en inglés)

Ver en GitHub

using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Services;

namespace DriveV3Snippets
{
    // Class to demonstrate use of Drive insert file API
    public class UploadBasic
    {
        /// <summary>
        /// Upload new file.
        /// </summary>
        /// <param name="filePath">Image path to upload.</param>
        /// <returns>Inserted file metadata if successful, null otherwise.</returns>
        public static string DriveUploadBasic(string filePath)
        {
            try
            {
                /* Load pre-authorized user credentials from the environment.
                 TODO(developer) - See https://developers.google.com/identity for
                 guides on implementing OAuth2 for your application. */
                GoogleCredential credential = GoogleCredential.GetApplicationDefault()
                    .CreateScoped(DriveService.Scope.Drive);

                // Create Drive API service.
                var service = new DriveService(new BaseClientService.Initializer
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "Drive API Snippets"
                });

                // Upload file photo.jpg on drive.
                var fileMetadata = new Google.Apis.Drive.v3.Data.File()
                {
                    Name = "photo.jpg"
                };
                FilesResource.CreateMediaUpload request;
                // Create a new file on drive.
                using (var stream = new FileStream(filePath,
                           FileMode.Open))
                {
                    // Create a new file, with metadata and stream.
                    request = service.Files.Create(
                        fileMetadata, stream, "image/jpeg");
                    request.Fields = "id";
                    request.Upload();
                }

                var file = request.ResponseBody;
                // Prints the uploaded file id.
                Console.WriteLine("File ID: " + file.Id);
                return file.Id;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else if (e is FileNotFoundException)
                {
                    Console.WriteLine("File not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

HTTP

Crea una solicitud POST para el URI /upload del método con el parámetro de búsqueda uploadType=multipart:

POST https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart
Crea el cuerpo de la solicitud. Dale formato al cuerpo según el tipo de contenido multiparte o relacionado [RFC 2387], que contiene 2 partes:
- Metadatos. Los metadatos deben ir primero y tener un encabezado Content-Type configurado como application/json; charset=UTF-8. Agrega los metadatos del archivo en formato JSON.
- Multimedia. El medio debe ir en segundo lugar y debe tener un encabezado Content-Type de cualquier tipo MIME. Agrega los datos del archivo a la parte multimedia.
Identifica cada parte con una string de límite, precedida por dos guiones. Además, agrega 2 guiones después de la string de límite final.
Agrega estos encabezados HTTP de nivel superior:
- Content-Type. Se establece en multipart/related y, además, incluye la string de límite que usas para identificar las diferentes partes de la solicitud. Por ejemplo: Content-Type: multipart/related; boundary=foo_bar_baz
- Content-Length. Configurado como la cantidad total de bytes en el cuerpo de la solicitud.
Envía la solicitud.

Para crear o actualizar solo la parte de metadatos, sin los datos asociados, envía una solicitud POST o PATCH al extremo de recurso estándar: https://www.googleapis.com/drive/v3/files Si la solicitud se realiza correctamente, el servidor muestra el código de estado HTTP 200 OK junto con los metadatos del archivo.

Cuando creas archivos, deben especificar una extensión en el campo name del archivo. Por ejemplo, cuando creas un archivo JPEG de fotos, puedes especificar algo como "name": "photo.jpg" en los metadatos. Las llamadas posteriores a files.get muestran la propiedad fileExtension de solo lectura que contiene la extensión que se especificó originalmente en el campo name.

Realiza una carga reanudable

Una carga reanudable te permite reanudar una operación de carga después de que una falla de comunicación interrumpa el flujo de datos. Debido a que no es necesario reiniciar las cargas de archivos grandes desde el comienzo, las cargas reanudables también pueden reducir el uso del ancho de banda si hay una falla de red.

Las cargas reanudables son útiles cuando los tamaños de tus archivos pueden variar considerablemente o cuando hay un límite de tiempo fijo para las solicitudes (como tareas en segundo plano de SO para dispositivos móviles y ciertas solicitudes de App Engine). También puedes usar cargas reanudables para las situaciones en las que desees mostrar una barra de progreso de carga.

Una carga reanudable consta de varios pasos de alto nivel:

Envía la solicitud inicial y recupera el URI de la sesión reanudable.
Sube los datos y supervisa el estado de carga.
(Opcional) Si se interrumpe la carga, reanúdala.

Envía la solicitud inicial

Para iniciar una carga reanudable, usa el método files.create con uploadType=resumable.

HTTP

Crea una solicitud POST para el URI /upload del método con el parámetro de búsqueda uploadType=resumable:

POST https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable

Si la solicitud de inicio se realiza de forma correcta, la respuesta incluirá un código de estado HTTP 200 OK. Además, incluye un encabezado Location que especifica el URI de la sesión reanudable:
```
HTTP/1.1 200 OK
Location: https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable&upload_id=xa298sd_sdlkj2
Content-Length: 0
```
Guarda el URI de la sesión reanudable para que puedas subir los datos del archivo y consultar el estado de la carga. Un URI de sesión reanudable vence después de una semana.

Nota: Para actualizar un archivo existente, usa PUT.
Si tienes metadatos para el archivo, agrégalos al cuerpo de la solicitud en formato JSON. De lo contrario, deja el cuerpo de la solicitud vacío.
Agrega estos encabezados HTTP:
- X-Upload-Content-Type. Es opcional. Se establece en el tipo de MIME de los datos del archivo, que se transfieren en solicitudes posteriores. Si el tipo de MIME de los datos no se especifica en los metadatos ni a través de este encabezado, el objeto se entrega como application/octet-stream..
- X-Upload-Content-Length. Es opcional. Se establece en la cantidad de bytes de los datos de archivos, que se transfieren en solicitudes posteriores.
- Content-Type. Es obligatorio si existen metadatos para el archivo. Se establece en application/json; charset=UTF-8.
- Content-Length. Es obligatorio, a menos que uses la codificación de transferencia fragmentada. Configurado como la cantidad de bytes en el cuerpo de esta solicitud inicial.
Envía la solicitud. Si la solicitud de inicio de sesión se realiza de forma correcta, la respuesta incluirá un código de estado 200 OK HTTP. Además, la respuesta incluye un encabezado Location que especifica el URI de la sesión reanudable. Usa el URI de la sesión reanudable para subir los datos del archivo y consultar el estado de la carga. Un URI de sesión reanudable vence después de una semana.
Copia y guarda la URL de la sesión reanudable.
Continúa con la sección Subir el contenido.

Sube el contenido

Existen 2 maneras de subir un archivo con una sesión reanudable:

Sube contenido en una sola solicitud: Usa este enfoque cuando el archivo se pueda subir en una solicitud, si no hay un límite fijo para ninguna solicitud o si no necesitas mostrar un indicador de progreso de carga. Este enfoque es mejor porque requiere menos solicitudes y da como resultado un mejor rendimiento.
Sube el contenido en varios fragmentos: Usa este enfoque si debes reducir la cantidad de datos transferidos en una sola solicitud. Es posible que debas reducir los datos transferidos cuando haya un límite de tiempo fijo para las solicitudes individuales, como puede ser el caso de ciertas clases de solicitudes de App Engine. Este enfoque también es útil si debes proporcionar un indicador personalizado para mostrar el progreso de la carga.

HTTP: solicitud única

Crea una solicitud PUT para el URI de la sesión reanudable.
Agrega los datos del archivo al cuerpo de la solicitud.
Agregue un encabezado HTTP de longitud del contenido establecido en la cantidad de bytes del archivo.
Envía la solicitud. Si se interrumpe la solicitud de carga o si recibes una respuesta 5xx, sigue el procedimiento de Reanuda una carga interrumpida.

HTTP: varias solicitudes

Crea una solicitud PUT para el URI de la sesión reanudable.
Agrega los datos del fragmento al cuerpo de la solicitud. Crea fragmentos en múltiplos de 256 KB (256 x 1,024 bytes), excepto por el fragmento final que completa la carga. Mantén el tamaño de los fragmentos lo más grande posible para que la carga sea eficiente.
Agrega estos encabezados HTTP:
- Content-Length. Se establece en la cantidad de bytes del fragmento actual.
- Content-Range. Configurado para que muestre qué bytes del archivo subes. Por ejemplo, Content-Range: bytes 0-524287/2000000 muestra que subes los primeros 524,288 bytes (256 x 1,024 x 2) de un archivo de 2,000,000 bytes.
Envía la solicitud y procesa la respuesta. Si se interrumpe la solicitud de carga o si recibes una respuesta 5xx, sigue el procedimiento que se describe en Reanuda una carga interrumpida.
Repite los pasos del 1 al 4 para cada fragmento que quede en el archivo. Usa el encabezado Range en la respuesta para determinar dónde comenzar la siguiente parte. No supongas que el servidor recibió todos los bytes que se enviaron en la solicitud anterior.

Cuando se completa la carga del archivo, recibes una respuesta 200 OK o 201 Created, junto con todos los metadatos asociados con el recurso.

Reanuda una carga interrumpida

Si se finaliza una solicitud de carga antes de una respuesta, o si recibes una respuesta 503 Service Unavailable, debes reanudar la carga interrumpida.

HTTP

Crea una solicitud PUT vacía para el URI de sesión reanudable a fin de solicitar el estado de la carga.
Agrega un encabezado Content-Range para indicar que se desconoce la posición actual en el archivo. Por ejemplo, configura Content-Range como */2000000 si el tamaño total del archivo es de 2,000,000 bytes. Si no conoces el tamaño completo del archivo, establece Content-Range en */*.
Envía la solicitud.
Procesa la respuesta:
- Una respuesta 200 OK o 201 Created indica que se completó la carga y que no es necesario realizar ninguna otra acción.
- Una respuesta 308 Resume Incomplete indica que debes seguir subiendo el archivo.
- Una respuesta 404 Not Found indica que la sesión de carga venció y que la carga debe reiniciarse desde el principio.
Si recibiste una respuesta 308 Resume Incomplete, procesa el encabezado Range de la respuesta para determinar qué bytes recibió el servidor. Si la respuesta no tiene un encabezado Range, no se recibieron bytes. Por ejemplo, un encabezado Range de bytes=0-42 indica que se recibieron los primeros 43 bytes del archivo y que el siguiente fragmento que se debe subir comenzaría con el byte 44.
Ahora que sabes dónde reanudar la carga, continúa subiendo el archivo a partir del siguiente byte. Incluye un encabezado Content-Range para indicar qué parte del archivo envías. Por ejemplo, Content-Range: bytes 43-1999999 indica que envías bytes desde el 44 hasta el 2,000,000.

Cómo controlar los errores de carga de contenido multimedia

Cuando subas contenido multimedia, sigue estas prácticas recomendadas para manejar los errores:

Para los errores 5xx, reanuda o vuelve a intentar las cargas que fallan debido a interrupciones de la conexión. Para obtener más información sobre cómo manejar los errores 5xx, consulta Cómo resolver un error 5xx.
Para 403 rate limit error, vuelva a subirlo. Para obtener más información sobre cómo manejar los errores 403 rate limit, consulta Cómo resolver una 403 error: Rate limit exceeded.
Para cualquier error 4xx (incluido 403) durante una carga reanudable, reinicia la carga. Estos errores indican que la sesión de carga venció y que se debe reiniciar mediante la solicitud de un URI de sesión nuevo. Las sesiones de carga también vencen después de una semana de inactividad.

Importar a tipos de Documentos de Google

Cuando creas un archivo en Drive, es posible que desees convertirlo en un tipo de archivo de Google Workspace, como un documento de Google o una hoja de cálculo de Google. Por ejemplo, tal vez quieras convertir un documento de tu procesador de texto favorito en un documento de Google para aprovechar sus funciones.

Para convertir un archivo en un tipo de archivo de Google Workspace específico, especifica el mimeType de Google Workspace cuando crees el archivo.

A continuación, se muestra cómo convertir un archivo CSV en una hoja de cálculo de Google Workspace:

Java

drive/snippets/drive_v3/src/main/java/UploadWithConversion.java

Ver en GitHub

import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.FileContent;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.drive.Drive;
import com.google.api.services.drive.DriveScopes;
import com.google.api.services.drive.model.File;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Arrays;

/* Class to demonstrate Drive's upload with conversion use-case. */
public class UploadWithConversion {

  /**
   * Upload file with conversion.
   *
   * @return Inserted file id if successful, {@code null} otherwise.
   * @throws IOException if service account credentials file not found.
   */
  public static String uploadWithConversion() throws IOException {
    // Load pre-authorized user credentials from the environment.
    // TODO(developer) - See https://developers.google.com/identity for
    // guides on implementing OAuth2 for your application.
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Arrays.asList(DriveScopes.DRIVE_FILE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Build a new authorized API client service.
    Drive service = new Drive.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Drive samples")
        .build();

    // File's metadata.
    File fileMetadata = new File();
    fileMetadata.setName("My Report");
    fileMetadata.setMimeType("application/vnd.google-apps.spreadsheet");

    java.io.File filePath = new java.io.File("files/report.csv");
    FileContent mediaContent = new FileContent("text/csv", filePath);
    try {
      File file = service.files().create(fileMetadata, mediaContent)
          .setFields("id")
          .execute();
      System.out.println("File ID: " + file.getId());
      return file.getId();
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      System.err.println("Unable to move file: " + e.getDetails());
      throw e;
    }
  }
}

Python

drive/snippets/drive-v3/file_snippet/upload_with_conversion.py

Ver en GitHub

from __future__ import print_function

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from googleapiclient.http import MediaFileUpload


def upload_with_conversion():
    """Upload file with conversion
    Returns: ID of the file uploaded

    Load pre-authorized user credentials from the environment.
    TODO(developer) - See https://developers.google.com/identity
    for guides on implementing OAuth2 for the application.
    """
    creds, _ = google.auth.default()

    try:
        # create drive api client
        service = build('drive', 'v3', credentials=creds)

        file_metadata = {
            'name': 'My Report',
            'mimeType': 'application/vnd.google-apps.spreadsheet'
        }
        media = MediaFileUpload('report.csv', mimetype='text/csv',
                                resumable=True)
        # pylint: disable=maybe-no-member
        file = service.files().create(body=file_metadata, media_body=media,
                                      fields='id').execute()
        print(F'File with ID: "{file.get("id")}" has been uploaded.')

    except HttpError as error:
        print(F'An error occurred: {error}')
        file = None

    return file.get('id')


if __name__ == '__main__':
    upload_with_conversion()

Node.js

drive/snippets/drive_v3/file_snippets/upload_with_conversion.js

Ver en GitHub

/**
 * Upload file with conversion
 * @return{obj} file Id
 * */
async function uploadWithConversion() {
  const fs = require('fs');
  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');
  // Get credentials and build service
  // TODO (developer) - Use appropriate auth mechanism for your app
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });
  const service = google.drive({version: 'v3', auth});
  const fileMetadata = {
    name: 'My Report',
    mimeType: 'application/vnd.google-apps.spreadsheet',
  };
  const media = {
    mimeType: 'text/csv',
    body: fs.createReadStream('files/report.csv'),
  };

  try {
    const file = await service.files.create({
      resource: fileMetadata,
      media: media,
      fields: 'id',
    });
    console.log('File Id:', file.data.id);
    return file.data.id;
  } catch (err) {
    // TODO(developer) - Handle error
    throw err;
  }
}

PHP

drive/snippets/drive_v3/src/DriveUploadWithConversion.php (en inglés)

Ver en GitHub

use Google\Client;
use Google\Service\Drive;
function uploadWithConversion()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $fileMetadata = new Drive\DriveFile(array(
            'name' => 'My Report',
            'mimeType' => 'application/vnd.google-apps.spreadsheet'));
        $content = file_get_contents('../files/report.csv');
        $file = $driveService->files->create($fileMetadata, array(
            'data' => $content,
            'mimeType' => 'text/csv',
            'uploadType' => 'multipart',
            'fields' => 'id'));
        printf("File ID: %s\n", $file->id);
        return $file->id;
    } catch(Exception $e) {
        echo "Error Message: ".$e;
    }

}

.NET

drive/snippets/drive_v3/DriveV3Snippets/UploadWithConversion.cs

Ver en GitHub

using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Services;

namespace DriveV3Snippets
{
    // Class to demonstrate Drive's upload with conversion use-case.
    public class UploadWithConversion
    {
        /// <summary>
        /// Upload file with conversion.
        /// </summary>
        /// <param name="filePath">Id of the spreadsheet file.</param>
        /// <returns>Inserted file id if successful, null otherwise.</returns>
        public static string DriveUploadWithConversion(string filePath)
        {
            try
            {
                /* Load pre-authorized user credentials from the environment.
                 TODO(developer) - See https://developers.google.com/identity for
                 guides on implementing OAuth2 for your application. */
                GoogleCredential credential = GoogleCredential.GetApplicationDefault()
                    .CreateScoped(DriveService.Scope.Drive);

                // Create Drive API service.
                var service = new DriveService(new BaseClientService.Initializer
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "Drive API Snippets"
                });

                // Upload file My Report on drive.
                var fileMetadata = new Google.Apis.Drive.v3.Data.File()
                {
                    Name = "My Report",
                    MimeType = "application/vnd.google-apps.spreadsheet"
                };
                FilesResource.CreateMediaUpload request;
                // Create a new drive.
                using (var stream = new FileStream(filePath,
                           FileMode.Open))
                {
                    // Create a new file, with metadata and stream.
                    request = service.Files.Create(
                        fileMetadata, stream, "text/csv");
                    request.Fields = "id";
                    request.Upload();
                }

                var file = request.ResponseBody;
                // Prints the uploaded file id.
                Console.WriteLine("File ID: " + file.Id);
                return file.Id;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else if (e is FileNotFoundException)
                {
                    Console.WriteLine("File not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

Para ver si hay una conversión disponible, verifica el arreglo importFormats del recurso About antes de crear el archivo. Las conversiones compatibles están disponibles de forma dinámica en este arreglo. Estos son algunos formatos comunes de importación:

Desde	A
Microsoft Word, texto de OpenDocument, HTML, RTF, texto sin formato	Documentos de Google
Microsoft Excel, hoja de cálculo de OpenDocument, CSV, TSV, texto sin formato	Hojas de cálculo de Google
Microsoft PowerPoint, presentación de OpenDocument	Presentaciones de Google
JPEG, PNG, GIF, BMP, PDF	Documentos de Google (incorpora la imagen en un documento)
Texto sin formato (tipo MIME especial), JSON	Google Apps Script

Cuando subes y conviertes contenido multimedia durante una solicitud update a un documento, hoja de cálculo o presentación, se reemplaza todo el contenido del documento.

Cuando conviertes una imagen en un documento, Drive usa el reconocimiento óptico de caracteres (OCR) para convertir la imagen en texto. Puedes mejorar la calidad del algoritmo de OCR si especificas el código de idioma BCP 47 aplicable en el parámetro ocrLanguage. El texto extraído aparece en el documento junto a la imagen incorporada.

Use un ID generado previamente para subir archivos

La API de Drive te permite recuperar una lista de ID de archivos generados previamente que se usan para subir y crear recursos. Las solicitudes de carga y creación de archivos pueden usar estos ID generados con anterioridad. Configura el campo id en los metadatos del archivo.

Para crear ID generados con anterioridad, llama a file.generateIds con la cantidad de ID que se crearán.

Puedes volver a intentarlo de forma segura con los ID generados previamente si hay un tiempo de espera o un error indeterminado del servidor. Si el archivo se creó de forma correcta, los reintentos posteriores mostrarán un error HTTP 409 y no crear archivos duplicados.

Cómo definir texto indexable para tipos de archivos desconocidos

Los usuarios pueden usar la IU de Drive para buscar contenido de documentos. También puedes usar files.list y el campo fullText para buscar contenido de tu app. Si quieres obtener más información, consulta Cómo buscar archivos y carpetas.

Drive indexa automáticamente los documentos para la búsqueda cuando reconoce el tipo de archivo, incluidos los documentos de texto, los PDF, las imágenes con texto y otros tipos comunes. Si tu app guarda otros tipos de archivos (como dibujos, video y accesos directos), puedes proporcionar texto indexable en el campo contentHints.indexableText del archivo para mejorar la visibilidad.

Para obtener más información sobre el texto indexable, consulta Administra metadatos de archivos.

Subir datos de archivos

Comparación entre el uso de PATCH y de PUT

Realiza una carga simple.

HTTP

Cómo realizar una carga multiparte

Java

Python

Node.js

PHP

.NET

HTTP

Realiza una carga reanudable

Envía la solicitud inicial

HTTP

Sube el contenido

HTTP: solicitud única

HTTP: varias solicitudes

Reanuda una carga interrumpida

HTTP

Cómo controlar los errores de carga de contenido multimedia

Importar a tipos de Documentos de Google

Java

Python

Node.js

PHP

.NET

Use un ID generado previamente para subir archivos

Cómo definir texto indexable para tipos de archivos desconocidos

Comparación entre el uso de `PATCH` y de `PUT`