Java

The Java client library is maintained in an open-source project on Google Project hosting. The Java library itself is distributed as a ZIP file, containing a number of JARs that applications can import in order to gain access to the library.

The Java client library requires JDK 5.0 or greater. The latest version of the Oracle JDK is available from http://www.oracle.com/technetwork/java/index.html.

Unfortunately, due to restrictive licensing, we cannot at this time just give developers a ZIP of all JARs required to interact with the API. Some of the JARs are not available without additional license agreements. Because of this, some of the JARs must be downloaded individually. We sincerely apologize for this inconvenience.

To setup a development environment for working with the Documents List API, perform the following steps.

1. Download the latest gdata-src.java-*.zip file from the project's Downloads page. Replace * in this case with something like 1.46.0.

2. Extract the ZIP file into a new directory.

   unzip gdata-src.java-1.46.0.zip -d ./gdata-java-client
   

3. Copy the JARs from gdata-java-client/gdata/java/lib into a directory included in the application's classpath.

   cp gdata-java-client/gdata/java/lib/* /path/to/application/lib
   

4. Copy the JARs from gdata-java-client/gdata/java/deps into the application's classpath.

   cp gdata-java-client/gdata/java/deps/* /path/to/application/lib
   

5. Download the JavaMail API (version 1.4 or greater) from here. Extract the ZIP file and copy mail.jar to the application's classpath.

   unzip javamail1_4_4.zip -d javamail
   cp javamail/javamail-1.4.4/mail.jar /path/to/application/lib
   

6. If using the Oracle JDK version 1.5, download the JavaBeans Activation Framework from here. Extract the ZIP file and copy activation.jar to the application's classpath.

   unzip jaf-1_1_1.zip -d jaf
   cp jaf/jaf-1.1.1/activation.jar /path/to/application/lib
   

7. To implement any of the code discussed in this document, use the following class template.

   import com.google.gdata.client.authn.oauth.*;
   import com.google.gdata.client.docs.*;
   import com.google.gdata.data.*;
   import com.google.gdata.data.batch.*;
   import com.google.gdata.data.docs.*;
   import com.google.gdata.util.*;
   
   import java.io.IOException;
   import java.net.*;
   import java.util.*;
   
   public class MyDocumentsListIntegration {
     public static void main(String[] args)
         throws AuthenticationException, MalformedURLException, IOException, ServiceException {
   
       // Application code here
   
     }
   }
   

8. Once the above template is in place, continue reading the rest of this document, applying the Java code samples as necessary.

.NET

The .NET client library is maintained in an open-source project on Google Project hosting. The .NET library itself is distributed as a MSI installer, containing a number of DLLs that applications can import in order to gain access to the library.

The .NET client library requires the .NET Framework 2.0 or greater.

To setup a development environment for working with the Documents List API, perform the following steps.

1. Download the latest Google_Data_API_Setup_*.msi file from the project's Downloads page. Replace * in this case with something like 1.9.0.0.

2. Run the installer and follow the instructions in the setup wizard.

3. To implement any of the code discussed in this document, use the following class template.

   using Google.GData.Client;
   using Google.GData.Documents;
   
   namespace MyDocumentsListIntegration
   {
     class Program {
       static void Main(string[] args)
       {
   
         // Application code here
   
       }
     }
   }
   

4. Once the above template is in place, continue reading the rest of this document, applying the .NET code samples as necessary.

.NET

The following example is copied from the google-gdata project's sample directory. It has been modified to accommodate the Documents List API, and is provided here for ease of reference.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      ////////////////////////////////////////////////////////////////////////////
      // STEP 1: Configure how to perform OAuth 2.0
      ////////////////////////////////////////////////////////////////////////////

      // TODO: Update the following information with that obtained from
      // https://code.google.com/apis/console. After registering
      // your application, these will be provided for you.

      string CLIENT_ID = "12345678.apps.googleusercontent.com";

      // This is the OAuth 2.0 Client Secret retrieved
      // above.  Be sure to store this value securely.  Leaking this
      // value would enable others to act on behalf of your application!
      string CLIENT_SECRET = "Gc0230jdsah01jqpowpgff";

      // Space separated list of scopes for which to request access.
      string SCOPE = "https://docs.google.com/feeds/ https://docs.googleusercontent.com/ https://spreadsheets.google.com/feeds/";

      // This is the Redirect URI for installed applications.
      // If you are building a web application, you have to set your
      // Redirect URI at https://code.google.com/apis/console.
      string REDIRECT_URI = "urn:ietf:wg:oauth:2.0:oob";

      ////////////////////////////////////////////////////////////////////////////
      // STEP 2: Set up the OAuth 2.0 object
      ////////////////////////////////////////////////////////////////////////////

      // OAuth2Parameters holds all the parameters related to OAuth 2.0.
      OAuth2Parameters parameters = new OAuth2Parameters();

      // Set your OAuth 2.0 Client Id (which you can register at
      // https://code.google.com/apis/console).
      parameters.ClientId = CLIENT_ID;

      // Set your OAuth 2.0 Client Secret, which can be obtained at
      // https://code.google.com/apis/console.
      parameters.ClientSecret = CLIENT_SECRET;

      // Set your Redirect URI, which can be registered at
      // https://code.google.com/apis/console.
      parameters.RedirectUri = REDIRECT_URI;

      ////////////////////////////////////////////////////////////////////////////
      // STEP 3: Get the Authorization URL
      ////////////////////////////////////////////////////////////////////////////

      // Set the scope for this particular service.
      parameters.Scope = SCOPE;

      // Get the authorization url.  The user of your application must visit
      // this url in order to authorize with Google.  If you are building a
      // browser-based application, you can redirect the user to the authorization
      // url.
      string authorizationUrl = OAuthUtil.CreateOAuth2AuthorizationUrl(parameters);
      Console.WriteLine(authorizationUrl);
      Console.WriteLine("Please visit the URL above to authorize your OAuth "
        + "request token.  Once that is complete, type in your access code to "
        + "continue...");
      parameters.AccessCode = Console.ReadLine();

      ////////////////////////////////////////////////////////////////////////////
      // STEP 4: Get the Access Token
      ////////////////////////////////////////////////////////////////////////////

      // Once the user authorizes with Google, the request token can be exchanged
      // for a long-lived access token.  If you are building a browser-based
      // application, you should parse the incoming request token from the url and
      // set it in OAuthParameters before calling GetAccessToken().
      OAuthUtil.GetAccessToken(parameters);
      string accessToken = parameters.AccessToken;
      Console.WriteLine("OAuth Access Token: " + accessToken);

      ////////////////////////////////////////////////////////////////////////////
      // STEP 5: Make an OAuth authorized request to Google
      ////////////////////////////////////////////////////////////////////////////

      // Initialize the variables needed to make the request
      GOAuth2RequestFactory requestFactory =
          new GOAuth2RequestFactory(null, "MyDocumentsListIntegration-v1", parameters);
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");
      service.RequestFactory = requestFactory;

      // Make the request to Google
      // See other portions of this guide for code to put here...
    }
  }
}

Java

The following example is copied from the gdata-java-client project's sample directory. It has been modified to accommodate the Spreadsheets API, and is provided here for ease of reference.

import com.google.gdata.client.authn.oauth.GoogleOAuthHelper;
import com.google.gdata.client.authn.oauth.GoogleOAuthParameters;
import com.google.gdata.client.authn.oauth.OAuthHmacSha1Signer;
import com.google.gdata.client.authn.oauth.OAuthRsaSha1Signer;
import com.google.gdata.client.authn.oauth.OAuthSigner;
import com.google.gdata.client.docs.*;
import com.google.gdata.data.Link;
import com.google.gdata.data.batch.BatchOperationType;
import com.google.gdata.data.batch.BatchStatus;
import com.google.gdata.data.batch.BatchUtils;
import com.google.gdata.data.docs.*;
import com.google.gdata.util.*;

import java.io.IOException;
import java.net.*;
import java.util.*;

public class MyDocumentsListIntegration {
  public static void main(String[] args)
      throws AuthenticationException, MalformedURLException, IOException, ServiceException {

    ////////////////////////////////////////////////////////////////////////////
    // STEP 1: Configure how to perform OAuth 1.0a
    ////////////////////////////////////////////////////////////////////////////

    boolean USE_RSA_SIGNING = false;

    // TODO: Update the following information with that obtained from
    // https://www.google.com/accounts/ManageDomains. After registering
    // your application, these will be provided for you.

    String CONSUMER_KEY = "yourappdomain.com";

    // TODO: Replace this with base-64 encoded private key conforming
    // to PKCS #8 standard, if and only if you will use RSA-SHA1
    // signing.  Otherwise, this is the OAuth Consumer Secret retrieved
    // above.  Be sure to store this value securely.  Leaking this
    // value would enable others to act on behalf of your application!
    String CONSUMER_SECRET = "Gc0230jdsah01jqpowpgff";

    // Space separated list of scopes for which to request access.
    String SCOPES = "https://docs.google.com/feeds/ https://docs.googleusercontent.com/ https://spreadsheets.google.com/feeds/";

    ////////////////////////////////////////////////////////////////////////////
    // STEP 2: Set up the OAuth objects
    ////////////////////////////////////////////////////////////////////////////

    // You first need to initialize a few OAuth-related objects.
    // GoogleOAuthParameters holds all the parameters related to OAuth.
    // OAuthSigner is responsible for signing the OAuth base string.
    GoogleOAuthParameters oauthParameters = new GoogleOAuthParameters();

    // Set your OAuth Consumer Key (which you can register at
    // https://www.google.com/accounts/ManageDomains).
    oauthParameters.setOAuthConsumerKey(CONSUMER_KEY);

    // Initialize the OAuth Signer.  If you are using RSA-SHA1, you must provide
    // your private key as a Base-64 string conforming to the PKCS #8 standard.
    // Visit http://code.google.com/apis/gdata/authsub.html#Registered to learn
    // more about creating a key/certificate pair.  If you are using HMAC-SHA1,
    // you must set your OAuth Consumer Secret, which can be obtained at
    // https://www.google.com/accounts/ManageDomains.
    OAuthSigner signer;
    if (USE_RSA_SIGNING){
      signer = new OAuthRsaSha1Signer(CONSUMER_SECRET);
    } else {
      oauthParameters.setOAuthConsumerSecret(CONSUMER_SECRET);
      signer = new OAuthHmacSha1Signer();
    }

    // Finally, create a new GoogleOAuthHelperObject.  This is the object you
    // will use for all OAuth-related interaction.
    GoogleOAuthHelper oauthHelper = new GoogleOAuthHelper(signer);

    ////////////////////////////////////////////////////////////////////////////
    // STEP 3: Get the Authorization URL
    ////////////////////////////////////////////////////////////////////////////

    // Set the scope for this particular service.
    oauthParameters.setScope(SCOPES);

    // This method also makes a request to get the unauthorized request token,
    // and adds it to the oauthParameters object, along with the token secret
    // (if it is present).
    oauthHelper.getUnauthorizedRequestToken(oauthParameters);

    // Get the authorization url.  The user of your application must visit
    // this url in order to authorize with Google.  If you are building a
    // browser-based application, you can redirect the user to the authorization
    // url.
    String requestUrl = oauthHelper.createUserAuthorizationUrl(oauthParameters);
    System.out.println(requestUrl);
    System.out.println("Please visit the URL above to authorize your OAuth "
        + "request token.  Once that is complete, press any key to "
        + "continue...");
    System.in.read();

    ////////////////////////////////////////////////////////////////////////////
    // STEP 4: Get the Access Token
    ////////////////////////////////////////////////////////////////////////////

    // Once the user authorizes with Google, the request token can be exchanged
    // for a long-lived access token.  If you are building a browser-based
    // application, you should parse the incoming request token from the url and
    // set it in GoogleOAuthParameters before calling getAccessToken().
    String token = oauthHelper.getAccessToken(oauthParameters);
    System.out.println("OAuth Access Token: " + token);
    System.out.println();

    ////////////////////////////////////////////////////////////////////////////
    // STEP 5: Make an OAuth authorized request to Google
    ////////////////////////////////////////////////////////////////////////////

    // Initialize the variables needed to make the request
    URL feedUrl = new URL(variables.getFeedUrl());
    System.out.println("Sending request to " + feedUrl.toString());
    System.out.println();
    DocsService service =
        new DocsService("MyDocumentsListIntegration-v1");

    // Set the OAuth credentials which were obtained from the step above.
    service.setOAuthCredentials(oauthParameters, signer);

    // Make the request to Google
    // See other portions of this guide for code to put here...

    ////////////////////////////////////////////////////////////////////////////
    // STEP 6: Revoke the OAuth token
    ////////////////////////////////////////////////////////////////////////////

    System.out.println("Revoking OAuth Token...");
    oauthHelper.revokeToken(oauthParameters);
    System.out.println("OAuth Token revoked...");
  }
}

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      ////////////////////////////////////////////////////////////////////////////
      // STEP 1: Configure how to perform OAuth 1.0a
      ////////////////////////////////////////////////////////////////////////////

      // TODO: Update the following information with that obtained from
      // https://www.google.com/accounts/ManageDomains. After registering
      // your application, these will be provided for you.

      string CONSUMER_KEY = "yourappdomain.com";

      // This is the OAuth Consumer Secret retrieved
      // above.  Be sure to store this value securely.  Leaking this
      // value would enable others to act on behalf of your application!
      string CONSUMER_SECRET = "Gc0230jdsah01jqpowpgff";

      // Space separated list of scopes for which to request access.
      string SCOPE = "https://docs.google.com/feeds/ https://docs.googleusercontent.com/ https://spreadsheets.google.com/feeds/";

      ////////////////////////////////////////////////////////////////////////////
      // STEP 2: Set up the OAuth object
      ////////////////////////////////////////////////////////////////////////////

      // OAuthParameters holds all the parameters related to OAuth.
      OAuthParameters parameters = new OAuthParameters();

      // Set your OAuth Consumer Key (which you can register at
      // https://www.google.com/accounts/ManageDomains).
      parameters.ConsumerKey = CONSUMER_KEY;

      // Set your OAuth Consumer Secret, which can be obtained at
      // https://www.google.com/accounts/ManageDomains.
      parameters.ConsumerSecret = CONSUMER_SECRET;

      // HMAC-SHA1 is the only signature method supported by the .NET library.
      parameters.SignatureMethod = OAuthBase.HMACSHA1SignatureType;

      ////////////////////////////////////////////////////////////////////////////
      // STEP 3: Get the Authorization URL
      ////////////////////////////////////////////////////////////////////////////

      // Set the scope for this particular service.
      parameters.Scope = SCOPE;

      // This method also makes a request to get the unauthorized request token,
      // and adds it to the oauthParameters object, along with the token secret
      // (if it is present).
      OAuthUtil.GetUnauthorizedRequestToken(parameters);

      // Get the authorization url.  The user of your application must visit
      // this url in order to authorize with Google.  If you are building a
      // browser-based application, you can redirect the user to the authorization
      // url.
      string authorizationUrl = OAuthUtil.CreateUserAuthorizationUrl(parameters);
      Console.WriteLine(authorizationUrl);
      Console.WriteLine("Please visit the URL above to authorize your OAuth "
        + "request token.  Once that is complete, press any key to "
        + "continue...");
      Console.ReadLine();

      ////////////////////////////////////////////////////////////////////////////
      // STEP 4: Get the Access Token
      ////////////////////////////////////////////////////////////////////////////

      // Once the user authorizes with Google, the request token can be exchanged
      // for a long-lived access token.  If you are building a browser-based
      // application, you should parse the incoming request token from the url and
      // set it in OAuthParameters before calling GetAccessToken().
      OAuthUtil.GetAccessToken(parameters);
      string accessToken = parameters.Token;
      Console.WriteLine("OAuth Access Token: " + accessToken);

      ////////////////////////////////////////////////////////////////////////////
      // STEP 5: Make an OAuth authorized request to Google
      ////////////////////////////////////////////////////////////////////////////

      // Initialize the variables needed to make the request
      GOAuthRequestFactory requestFactory =
          new GOAuthRequestFactory(null, "MyDocumentsListIntegration-v1", parameters);
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");
      service.RequestFactory = requestFactory;

      // Make the request to Google
      // See other portions of this guide for code to put here...
    }
  }
}

Protocol

Detailed information on implementing ClientLogin from a protocol perspective is available here.

When fetching a ClientLogin token for the Documents List API, be sure to use the writely service name.

Java

The following is a code sample in which a DocsService object is configured to use ClientLogin for authorization.

import com.google.gdata.client.docs.*;
import com.google.gdata.data.docs.*;
import com.google.gdata.util.*;

import java.io.IOException;
import java.net.*;

public class MyDocumentsListIntegration {
  public static void main(String[] args)
      throws AuthenticationException, MalformedURLException, IOException, ServiceException {

    String USERNAME = "someuser@gmail.com";
    String PASSWORD = "testing123";

    DocsService service = new DocsService("MyDocumentsListIntegration-v1");
    service.setUserCredentials(USERNAME, PASSWORD);

    // TODO: See other portions of this guide for code to put here...
  }
}

.NET

The following is a code sample in which a DocumentsService object is configured to use ClientLogin for authorization.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      string USERNAME = "someuser@gmail.com";
      string PASSWORD = "testing123";

      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");
      service.setUserCredentials(USERNAME, PASSWORD);

      // TODO: See other portions of this guide for code to put here...
    }
  }
}

Protocol

GET https://docs.google.com/feeds/metadata/default

<entry xmlns="http://www.w3.org/2005/Atom" xmlns:docs="http://schemas.google.com/docs/2007" xmlns:gAcl="http://schemas.google.com/acl/2007" xmlns:gd="http://schemas.google.com/g/2005" gd:etag="W/"CkcMQH0zcSt7ImA9WhdQF0w."">
  <id>https://docs.google.com/feeds/metadata/user%40example.com</id>
  <updated>2011-08-18T23:28:01.389Z</updated>
  <category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/docs/2007#metadata" label="metadata"/>
  <title>Document List User Metadata</title>
  <link rel="self" type="application/atom+xml" href="https://docs.google.com/feeds/metadata/user%40example.com"/>
  <author>
    <name>Some User</name>
    <email>user@example.com</email>
  </author>
  <gd:quotaBytesTotal>1073741824</gd:quotaBytesTotal>
  <gd:quotaBytesUsed>17936436</gd:quotaBytesUsed>
  <docs:quotaBytesUsedInTrash>0</docs:quotaBytesUsedInTrash>
  <docs:largestChangestamp value="101019"/>
  <docs:importFormat source="application/vnd.openxmlformats-officedocument.presentationml.presentation" target="presentation"/>
  <docs:importFormat source="application/vnd.ms-powerpoint" target="presentation"/>
  <docs:importFormat source="text/tab-separated-values" target="spreadsheet"/>
  <docs:importFormat source="image/gif" target="document"/>
  <docs:importFormat source="application/x-msmetafile" target="drawing"/>
  <docs:importFormat source="application/vnd.sun.xml.writer" target="document"/>
  <docs:importFormat source="image/png" target="document"/>
  <docs:importFormat source="application/vnd.ms-excel" target="spreadsheet"/>
  <docs:importFormat source="image/bmp" target="document"/>
  <docs:importFormat source="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" target="spreadsheet"/>
  <docs:importFormat source="application/rtf" target="document"/>
  <docs:importFormat source="application/msword" target="document"/>
  <docs:importFormat source="application/vnd.oasis.opendocument.text" target="document"/>
  <docs:importFormat source="text/plain" target="document"/>
  <docs:importFormat source="text/csv" target="spreadsheet"/>
  <docs:importFormat source="image/jpeg" target="document"/>
  <docs:importFormat source="application/x-vnd.oasis.opendocument.spreadsheet" target="spreadsheet"/>
  <docs:importFormat source="application/pdf" target="document"/>
  <docs:importFormat source="application/vnd.openxmlformats-officedocument.wordprocessingml.document" target="document"/>
  <docs:importFormat source="text/html" target="document"/>
  <docs:exportFormat source="drawing" target="image/png"/>
  <docs:exportFormat source="drawing" target="application/pdf"/>
  <docs:exportFormat source="drawing" target="image/jpeg"/>
  <docs:exportFormat source="document" target="application/msword"/>
  <docs:exportFormat source="drawing" target="image/svg+xml"/>
  <docs:exportFormat source="spreadsheet" target="application/pdf"/>
  <docs:exportFormat source="document" target="application/rtf"/>
  <docs:exportFormat source="spreadsheet" target="application/x-vnd.oasis.opendocument.spreadsheet"/>
  <docs:exportFormat source="presentation" target="text/plain"/>
  <docs:exportFormat source="document" target="application/pdf"/>
  <docs:exportFormat source="document" target="text/plain"/>
  <docs:exportFormat source="document" target="text/html"/>
  <docs:exportFormat source="presentation" target="application/vnd.ms-powerpoint"/>
  <docs:exportFormat source="spreadsheet" target="application/vnd.ms-excel"/>
  <docs:exportFormat source="document" target="application/vnd.oasis.opendocument.text"/>
  <docs:exportFormat source="document" target="text/rtf"/>
  <docs:exportFormat source="presentation" target="application/pdf"/>
  <docs:feature>
    <docs:featureName>ocr</docs:featureName>
  </docs:feature>
  <docs:feature>
    <docs:featureName>translation</docs:featureName>
    <docs:featureRate>2.0</docs:featureRate>
  </docs:feature>
  <docs:feature>
    <docs:featureName>upload_any</docs:featureName>
  </docs:feature>
  <docs:maxUploadSize kind="document">26214400</docs:maxUploadSize>
  <docs:maxUploadSize kind="spreadsheet">10485760</docs:maxUploadSize>
  <docs:maxUploadSize kind="presentation">10485760</docs:maxUploadSize>
  <docs:maxUploadSize kind="drawing">2097152</docs:maxUploadSize>
  <docs:maxUploadSize kind="pdf">10737418240</docs:maxUploadSize>
  <docs:maxUploadSize kind="file">10737418240</docs:maxUploadSize>
  <!-- The document resource type supports the additionalRoleSets given within. -->
  <docs:additionalRoleInfo kind="document">
    <!-- The reader role supports all additionalRoles given within. -->
    <docs:additionalRoleSet primaryRole="reader">
      <!-- Readers of text document resources are also able to comment on said
      resources if the relevant additionalRole is provided in an ACL entry. -->
      <gAcl:additionalRole value="commenter"/>
    </docs:additionalRoleSet>
  </docs:additionalRoleInfo>
</entry>

.NET

The following code fetches the feature set available to the currently authenticated user's account, and prints out the quota information and the list of supported import formats.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a MetadataQuery object to retrieve metadata.
      MetadataQuery query = new MetadataQuery();

      // Make a request to the API and get all information.
      MetadataFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        throw new Exception("The metadata feed should always contain an entry");
      }

      // The metadata feed contains a single entry
      MetadataEntry entry = (MetadataEntry)feed.Entries[0];

      // Print quota information to the screen
      Console.WriteLine(entry.QuotaBytesUsed);
      Console.WriteLine(entry.QuotaBytesTotal);

      // Iterate through all of the supported import formats
      foreach (ConversionFormat format in entry.ImportFormats)
      {
        // Print the source and target formats
        Console.WriteLine(format.Source + " -> " + format.Target);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/metadata/default?remaining-changestamps-first=[changestamp-plus-one]&remaining-changestamps-limit=500

<entry xmlns="http://www.w3.org/2005/Atom"
    xmlns:docs="http://schemas.google.com/docs/2007"
    xmlns:gAcl="http://schemas.google.com/acl/2007"
    xmlns:gd="http://schemas.google.com/g/2005"
    gd:etag="W/"CkcMQH0zcSt7ImA9WhdQF0w."">
  ...
  <docs:remainingChangestamps>344</docs:remainingChangestamps>
  ...
</entry>

.NET

The following code fetches the number of changestamps since changestamp 100, up to 500 changestamps.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a MetadataQuery object to retrieve metadata.
      MetadataQuery query = new MetadataQuery();

      // Set the RemainingChangestampsFirst parameter.
      query.RemainingChangestampsFirst = 100;

      // Set the RemainingChangestampsLimit parameter.
      query.RemainingChangestampsLimit = 500;

      // Make a request to the API and get all information.
      MetadataFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        throw new Exception("The metadata feed should always contain an entry");
      }

      // The metadata feed contains a single entry
      MetadataEntry entry = (MetadataEntry)feed.Entries[0];

      // Print the number of remaining changestamps to the screen
      Console.WriteLine(entry.RemainingChangestamps);
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/changes

<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xmlns:openSearch="http://a9.com/-/spec/opensearch/1.1/"
    xmlns:docs="http://schemas.google.com/docs/2007" xmlns:gd="http://schemas.google.com/g/2005"
    gd:etag="W/"DEEMQ3w8eyt7ImA9WhZUGUo."">
  <id>https://docs.google.com/feeds/default/private/changes</id>
  <updated>2011-06-13T14:51:22.273Z</updated>
  <category scheme="http://schemas.google.com/g/2005#kind"
      term="http://schemas.google.com/docs/2007#change" label="change"/>
  <title>Changed Documents - joe.smith@example.com</title>

  <!-- Largest changestamp for the currently authorized user. -->
  <!-- This value is also given in the Metadata feed. -->
  <docs:largestChangestamp value="5635"/>

  <!-- Follow this to get the next set of changes. -->
  <!-- If this is not provided, there are no additional changes at the current time. -->
  <link rel="next" type="application/atom+xml"
      href="https://docs.google.com/feeds/default/private/changes?start-index=5636"/>

  <link rel="http://schemas.google.com/g/2005#feed" type="application/atom+xml"
      href="https://docs.google.com/feeds/default/private/changes"/>
  <link rel="self" type="application/atom+xml"
      href="https://docs.google.com/feeds/default/private/changes?start-index=5620"/>
  <author>
    <name>joe.smith</name>
    <email>joe.smith@example.com</email>
  </author>
  <openSearch:totalResults>5635</openSearch:totalResults>
  <openSearch:startIndex>5620</openSearch:startIndex>

  <!-- This change represents a document being permanently deleted. -->
  <entry gd:etag="W/"DUcMRHg5cCt7ImA9WhZUGUo."">
    <id>https://docs.google.com/feeds/id/unknown%3A1H38bELcnXOWXL8eRZYAP4XvfR_EpEu_AJ1GZNJb9-N-4</id>
    <updated>2011-06-13T14:58:05.628Z</updated>

    <!-- Label representing that this is a change entry. -->
    <category scheme="http://schemas.google.com/g/2005#kind"
    term="http://schemas.google.com/docs/2007#change" label="change"/>

    <!-- docs:removed means this is change is a permanent deletion.  Use this to detect deletes. -->
    <!-- This field does NOT mean this resource was trashed.  To identify trashed resources, use the gd:deleted tag. -->
    <docs:removed/>

    <!-- Title is unknown because this change is a deletion. -->
    <title>Unknown</title>

    <!-- Content link is empty because this change is a deletion. -->
    <content/>

    <link rel="self" type="application/atom+xml"
        href="https://docs.google.com/feeds/default/private/changes/5623"/>

    <!-- Author is unknown because this change is a deletion. -->
    <author>
      <name>Unknown</name>
    </author>

    <!-- Resource type is unknown because this change is a deletion. -->
    <gd:resourceId>unknown:1H38bELcnXOWXL8eRZYAP4XvfR_EpEu_AJ1GZNJb9-N-4</gd:resourceId>

    <!-- Unique identifier for this change.  Store this to query again in the future. -->
    <docs:changestamp value="5623"/>
  </entry>

  <!-- This change represents a document being permanently deleted. -->
  <entry gd:etag="W/"DUYEQH85cCt7ImA9WhZUGUo."">
    <id>https://docs.google.com/feeds/id/unknown%3A17vRlM9HeTv_V03nxDXXnl9QvY-sL53e4tbiE0-5xD7e4</id>
    <updated>2011-06-13T14:58:21.128Z</updated>
    <category scheme="http://schemas.google.com/g/2005#kind"
        term="http://schemas.google.com/docs/2007#change" label="change"/>
    <title>Unknown</title>
    <content/>
    <link rel="self" type="application/atom+xml"
        href="https://docs.google.com/feeds/default/private/changes/5630"/>
    <author>
      <name>Unknown</name>
    </author>
    <gd:resourceId>unknown:17vRlM9HeTv_V03nxDXXnl9QvY-sL53e4tbiE0-5xD7e4</gd:resourceId>
    <docs:removed/>
    <docs:changestamp value="5630"/>
  </entry>

  <!-- This change represents a document being created. -->
  <entry gd:etag=""BlAIEQdOHCt7ImBr"">
    <id>https://docs.google.com/feeds/id/document%3A1DJ1Qrt_N41aX1nDxxo0QHs5XIM90zTT-seYG2FYxrRk</id>
    <published>2011-06-13T15:05:37.544Z</published>
    <updated>2011-06-13T15:05:38.108Z</updated>
    <app:edited xmlns:app="http://www.w3.org/2007/app">2011-06-13T15:05:38.456Z</app:edited>
    <category scheme="http://schemas.google.com/g/2005#kind"
        term="http://schemas.google.com/docs/2007#document" label="document"/>
    <category scheme="http://schemas.google.com/g/2005/labels"
        term="http://schemas.google.com/g/2005/labels#viewed" label="viewed"/>
    <title>Meeting Notes</title>
    <content type="text/html"
        src="https://docs.google.com/feeds/download/documents/export/Export?id=1DJ1Qrt_N41aX1nDxxo0QHs5XIM90zTT-seYG2FYxrRk"/>
    <link rel="alternate" type="text/html"
        href="https://docs.google.com/a/example.com/document/d/1DJ1Qrt_N41aX1nDxxo0QHs5XIM90zTT-seYG2FYxrRk/edit?hl=en_US"/>
    <link rel="http://schemas.google.com/g/2005#resumable-edit-media" type="application/atom+xml"
        href="https://docs.google.com/feeds/upload/create-session/default/private/full/document%3A1DJ1Qrt_N41aX1nDxxo0QHs5XIM90zTT-seYG2FYxrRk"/>
    <link rel="http://schemas.google.com/docs/2007/thumbnail" type="image/jpeg"
        href="https://lh5.googleusercontent.com/u7NNUBIcKwb74epx_cb5ff_UoJDo5wm5M9zVRZq33qDfTnJyYo98uvP1CYI6hkEGFzEzG_QwqnLOabNkAg=s220"/>
    <link rel="edit" type="application/atom+xml"
        href="https://docs.google.com/feeds/default/private/full/document%3A1DJ1Qrt_N41aX1nDxxo0QHs5XIM90zTT-seYG2FYxrRk"/>
    <link rel="edit-media" type="text/html"
        href="https://docs.google.com/feeds/default/media/document%3A1DJ1Qrt_N41aX1nDxxo0QHs5XIM90zTT-seYG2FYxrRk"/>
    <link rel="self" type="application/atom+xml"
        href="https://docs.google.com/feeds/default/private/changes/5635"/>
    <author>
      <name>joe.smith</name>
      <email>joe.smith@example.com</email>
    </author>
    <gd:resourceId>document:1DJ1Qrt_N41aX1nDxxo0QHs5XIM90zTT-seYG2FYxrRk</gd:resourceId>
    <gd:lastModifiedBy>
      <name>joe.smith</name>
      <email>joe.smith@example.com</email>
    </gd:lastModifiedBy>
    <gd:lastViewed>2011-06-13T15:05:38.108Z</gd:lastViewed>
    <gd:quotaBytesUsed>0</gd:quotaBytesUsed>
    <docs:writersCanInvite value="true"/>
    <docs:changestamp value="5635"/>
    <gd:feedLink rel="http://schemas.google.com/acl/2007#accessControlList"
        href="https://docs.google.com/feeds/default/private/full/document%3A1DJ1Qrt_N41aX1nDxxo0QHs5XIM90zTT-seYG2FYxrRk/acl"/>
    <gd:feedLink rel="http://schemas.google.com/docs/2007/revisions"
        href="https://docs.google.com/feeds/default/private/full/document%3A1DJ1Qrt_N41aX1nDxxo0QHs5XIM90zTT-seYG2FYxrRk/revisions"/>
  </entry>

...
</feed>

.NET

The following code fetches a list of the currently authenticated user's changes, and prints out the title and changestamp of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a ChangesQuery object to retrieve changes.
      ChangesQuery query = new ChangesQuery();

      // Make a request to the API and get all changes.
      ChangesFeed feed = service.Query(query);

      // Iterate through all of the changes returned
      foreach (ChangeEntry entry in feed.Entries)
      {
        // Print the title and changestamp of this document to the screen
        Console.WriteLine(entry.Title.Text);
        Console.WriteLine(entry.Changestamp);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/changes?start-index=4352

.NET

The following code fetches a list of the currently authenticated user's changes, starting from change 4352, and prints out the title and changestamp of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a ChangesQuery object to retrieve changes.
      ChangesQuery query = new ChangesQuery();

      // Set the StartIndex parameter.
      query.StartIndex = 4352;

      // Make a request to the API and get all changes.
      ChangesFeed feed = service.Query(query);

      // Iterate through all of the changes returned
      foreach (ChangeEntry entry in feed.Entries)
      {
        // Print the title and changestamp of this document to the screen
        Console.WriteLine(entry.Title.Text);
        Console.WriteLine(entry.Changestamp);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/changes?start-index=[changestamp-plus-one]&max-results=900

.NET

The following code fetches a list of up to 900 of the currently authenticated user's changes, starting from change 4352, and prints out the title and changestamp of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a ChangesQuery object to retrieve changes.
      ChangesQuery query = new ChangesQuery();

      // Set the StartIndex parameter.
      query.StartIndex = 4352;

      // Set the NumberToRetrieve parameter.
      query.NumberToRetrieve = 900;

      // Make a request to the API and get all changes.
      ChangesFeed feed = service.Query(query);

      // Iterate through all of the changes returned
      foreach (ChangeEntry entry in feed.Entries)
      {
        // Print the title and changestamp of this document to the screen
        Console.WriteLine(entry.Title.Text);
        Console.WriteLine(entry.Changestamp);
      }
    }
  }
}

Protocol

https://docs.google.com/feeds/default/private/changes?start-index=[changestamp-plus-one]&expand-acl=true

.NET

The following code fetches a list of the currently authenticated user's changes, starting from change 4352 and with expanded ACL, and prints out the title and changestamp of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a ChangesQuery object to retrieve changes.
      ChangesQuery query = new ChangesQuery();

      // Set the StartIndex parameter.
      query.StartIndex = 4352;

      // Set the ExpandAcl parameter.
      query.ExpandAcl = true;

      // Make a request to the API and get all changes.
      ChangesFeed feed = service.Query(query);

      // Iterate through all of the changes returned
      foreach (ChangeEntry entry in feed.Entries)
      {
        // Print the title and changestamp of this document to the screen
        Console.WriteLine(entry.Title.Text);
        Console.WriteLine(entry.Changestamp);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full?include-profile-info=true

...
<entry>
  ...
  <gd:lastModifiedBy>
    <name>Joe Smith</name>
    <uri>https://lh5.googleusercontent.com/-4IL6021224n0/AAAAAAI/AAREAAAA/rc12312LidA/photo.jpg</uri>
    <email>joe.smith.test@gmail.com</email>
  </gd:lastModifiedBy>
  ...
</entry>
...

.NET

The following code fetches a list of the currently authenticated user's documents, and prints out the email address of the user who last modified each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Set the IncludeProfileInfo parameter.
      query.IncludeProfileInfo = true;

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the email address of the user who last modified the document.
        Console.WriteLine(entry.LastModified.EMail);
      }
    }
  }
}

Protocol

You can get a feed containing a list of the currently authenticated user's documents and files by sending an authorized GET request to the following URL:

https://docs.google.com/feeds/default/private/full

The result is a feed that lists the user's documents and files; each entry in the feed represents a resource associated with the user.

The result will look something like this (comments have been added for clarity):

<feed xmlns="http://www.w3.org/2005/Atom" xmlns:openSearch="http://a9.com/-/spec/opensearch/1.1/"
      xmlns:docs="http://schemas.google.com/docs/2007" xmlns:batch="http://schemas.google.com/gdata/batch"
      xmlns:gd="http://schemas.google.com/g/2005" gd:etag="W/&quot;DUMFR3YyfCt7ImA9WxNTFU0.&quot;">

  <!-- Unique identifier of this feed.  Not unique between users. -->
  <id>https://docs.google.com/feeds/default/private/full</id>

  <!-- Date this feed was last updated.  Do NOT use this, provided for Atom compliance only. -->
  <updated>2009-08-17T11:10:16.894Z</updated>

  <!-- Title of this feed result. -->
  <title>Available Documents - john.smith.example@gmail.com</title>

  <!-- Link at which a user could consume the same content given here, but in a web browser with a user interface. -->
  <link rel="alternate" type="text/html" href="https://docs.google.com"/>

  <!-- Link at which you can add documents or files using resumable upload. -->
  <link rel="http://schemas.google.com/g/2005#resumable-create-media" type="application/atom+xml"
      href="https://docs.google.com/feeds/upload/create-session/default/private/full"/>

  <!-- Link at which you can fetch the next page of results from this feed. -->
  <link rel="next" type="application/atom+xml"
      href="https://docs.google.com/feeds/default/private/full?start-key=EAEaFgoSCb2YGEPMAAACAG"/>

  <!-- Link at which you can fetch this same feed. -->
  <link rel="self" type="application/atom+xml"
      href="https://docs.google.com/feeds/default/private/full/"/>

  <!-- Link at which you can fetch this same feed. -->
  <link rel="http://schemas.google.com/g/2005#feed" type="application/atom+xml"
      href="https://docs.google.com/feeds/default/private/full"/>

  <!-- Deprecated.  Use resumable-create-media instead. -->
  <!-- Link at which you can POST new entries with metadata only to this feed. -->
  <link rel="http://schemas.google.com/g/2005#post" type="application/atom+xml"
      href="https://docs.google.com/feeds/default/private/full"/>

  <!-- Link at which you can send batch requests to this feed. -->
  <link rel="http://schemas.google.com/g/2005#batch" type="application/atom+xml"
      href="https://docs.google.com/feeds/default/private/full/batch"/>

  <!-- Information about the user who authorized this request. -->
  <author>
    <name>John Smith</name>
    <email>john.smith.example@gmail.com</email>
  </author>

  <!-- NOT supported, provided for protocol compliance only. -->
  <openSearch:startIndex>1</openSearch:startIndex>

  <!-- The ETag here is used to identify the version of this entry. -->
  <entry gd:etag="'EVJVTBICRit7ImBq'">

    <!-- A unique, permanent identifier for this entry. -->
    <id>https://docs.google.com/feeds/id/document%3A12345</id>

    <!-- Title of this resource. -->
    <title>2010 Income Tax Policy</title>

    <!-- Description of this resource (currently visible in the preview pane in the UI). -->
    <docs:description>Describes how to file income tax for 2010.</docs:description>

    <!-- Resource ID of this document. -->
    <gd:resourceId>document:12345</gd:resourceId>

    <!-- Date this document was created (the "published" name of this element is mis-leading, but this is Atom standard). -->
    <published>2009-07-22T19:02:57.616Z</published>

    <!-- Information about the owner of this document (not necessarily the user authorizing this request). -->
    <author>
      <name>Jenna Dolsom</name>
      <email>jenna.dolsom.example@gmail.com</email>
    </author>

    <!-- Date this entry was last updated (either by Google's systems, the API, or a user in a web browser). -->
    <updated>2009-07-29T20:31:39.804Z</updated>

    <!-- Date this document was last edited by a user in the document editor in a web browser. -->
    <app:edited xmlns:app="http://www.w3.org/2007/app">2009-07-31T17:21:26.497Z</app:edited>

    <!-- Information about the user who last modified this entry (not necessarily the user authorizing this request). -->
    <gd:lastModifiedBy>
      <name>Aaron Jensen</name>
      <email>aaron.jensen.example@gmail.com</email>
    </gd:lastModifiedBy>

    <!-- Date this document was last viewed in a web browser by any user. -->
    <gd:lastViewed>2009-07-31T17:21:26.273Z</gd:lastViewed>

    <!-- The "kind" of this entry.  In this case, a word processing document. -->
    <category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/docs/2007#document" label="document"/>

    <!-- This entry has been viewed by the user, so it has a "viewed" category. -->
    <category scheme="http://schemas.google.com/g/2005/labels" term="http://schemas.google.com/g/2005/labels#viewed" label="viewed"/>

    <!-- Link at which you can download the actual document this entry describes. -->
    <content type="text/html" src="https://docs.google.com/feeds/download/documents/Export?docId=12345"/>

    <!-- This document is in one collection, detailed here. -->
    <link rel="http://schemas.google.com/docs/2007#parent" type="application/atom+xml"
        href="https://docs.google.com/feeds/default/private/full/folder%3A12345" title="ACollectionName"/>

    <!-- Link at which you can open this document in a web browser. -->
    <link rel="alternate" type="text/html" href="https://docs.google.com/Doc?docid=12345&amp;hl=en"/>

    <!-- Link at which you can fetch only this entry. -->
    <link rel="self" type="application/atom+xml" href="https://docs.google.com/feeds/default/private/full/document%3A12345"/>

    <!-- Link at which you can PUT updates to this entry. -->
    <link rel="edit" type="application/atom+xml" href="https://docs.google.com/feeds/default/private/full/document%3A12345"/>

    <!-- Link at which you can PUT updates to this entry's content (deprecated, use resumable below). -->
    <link rel="edit-media" type="text/html" href="https://docs.google.com/feeds/default/media/document%3A12345"/>

    <!-- Link at which you can PUT resumable updates to this entry's content. -->
    <link rel="http://schemas.google.com/g/2005#resumable-edit-media" type="application/atom+xml"
        href="https://docs.google.com/feeds/upload/create-session/default/private/full/document%3A12345"/>

    <!-- Link at which you can fetch a thumbnail of this resource. -->
    <link rel="http://schemas.google.com/docs/2007/thumbnail" type="image/jpeg" href="https://lh3.googleusercontent.com/TQRs812345=s220"/>

    <!-- Link at which you can create, retrieve, update, and delete ACL entries for this document. -->
    <gd:feedLink rel="http://schemas.google.com/acl/2007#accessControlList"
         href="https://docs.google.com/feeds/default/private/full/document%3A12345/acl"/>

    <!-- Link at which you can create, retrieve, update, and delete revisions of this document. -->
    <gd:feedLink rel="http://schemas.google.com/docs/2007/revisions"
         href="https://docs.google.com/feeds/default/private/full/document%3A12345/revisions"/>

    <!-- Number of bytes of the owner's quota this document uses.  Native Google Docs currently use 0 bytes. -->
    <gd:quotaBytesUsed>0</gd:quotaBytesUsed>

    <!-- "true" if writers can invite other users to view and edit this document. -->
    <docs:writersCanInvite value="true"/>

    <!-- Given for files only. An MD5 checksum used to verify the contents of this file. -->
    <!-- Some old files are being processed. Those files will not have this element yet. -->
    <docs:md5Checksum>2b01142f7481c7b056c4b410d28f33cf</docs:md5Checksum>

    <!-- Original filename of file at time of upload, if available. -->
    <!-- Only available for resources of type file or pdf. -->
    <!-- Shown here as example only. This element is not given for resources of type document. -->
    <docs:filename>MyFile.pdf</docs:filename>

    <!-- Current name of resource, with file extension from docs:filename appended, if available. -->
    <!-- If the current name already has an extension, then the extension from docs:filename is not appended. -->
    <!-- If docs:filename does not have an extension, then the current name is given unaltered. -->
    <!-- Only available for resources of type file or pdf. -->
    <!-- Shown here as example only. This element is not given for resources of type document. -->
    <docs:suggestedFilename>TaxDocument.pdf</docs:suggestedFilename>
  </entry>
  <entry xmlns:gd="http://schemas.google.com/g/2005" gd:etag="'HhJSFgpeRyt7ImBq'">
    <id>https://docs.google.com/feeds/id/pdf%3A12345</id>
    <published>2009-04-09T18:23:09.035Z</published>
    <updated>2009-04-09T18:23:09.035Z</updated>
    <app:edited xmlns:app="http://www.w3.org/2007/app">2009-06-18T22:16:02.388Z</app:edited>
    <category scheme="http://schemas.google.com/g/2005/labels" term="http://schemas.google.com/g/2005/labels#starred" label="starred"/>
    <category scheme="http://schemas.google.com/g/2005/labels" term="http://schemas.google.com/g/2005/labels#viewed" label="viewed"/>
    <category scheme="http://schemas.google.com/g/2005/labels" term="http://schemas.google.com/g/2005/labels#hidden" label="hidden"/>
    <category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/docs/2007#pdf" label="pdf"/>
    <title>PDF's Title</title>
    <content type="application/pdf"
         src="https://doc-04-20-docs.googleusercontent.com/docs/secure/m71240...U1?h=1630126&amp;e=download&amp;gd=true"/>
    <link rel="alternate" type="text/html" href="https://docs.google.com/fileview?id=12345&amp;hl=en"/>
    <link rel="self" type="application/atom+xml" href="https://docs.google.com/feeds/default/private/full/pdf%3A12345"/>
    <link rel="edit" type="application/atom+xml" href="https://docs.google.com/feeds/default/private/full/pdf%3A12345"/>
    <link rel="edit-media" type="application/pdf" href="https://docs.google.com/feeds/default/media/pdf%3A12345"/>
    <link rel="http://schemas.google.com/g/2005#resumable-edit-media" type="application/atom+xml"
        href="https://docs.google.com/feeds/upload/create-session/default/private/full/pdf%3A12345"/>
    <author>
      <name>user</name>
      <email>user@gmail.com</email>
    </author>
    <gd:resourceId>pdf:12345</gd:resourceId>
    <gd:lastModifiedBy>
      <name>user</name>
      <email>user@gmail.com</email>
    </gd:lastModifiedBy>
    <gd:lastViewed>2009-06-18T22:16:02.384Z</gd:lastViewed>
    <gd:quotaBytesUsed>108538</gd:quotaBytesUsed>
    <docs:writersCanInvite value="false"/>
    <docs:md5Checksum>2b01142f7481c7b056c4b410d28f33cf</docs:md5Checksum>
    <gd:feedLink rel="http://schemas.google.com/acl/2007#accessControlList"
         href="https://docs.google.com/feeds/default/private/full/pdf%3A12345/acl"/>
    <gd:feedLink rel="http://schemas.google.com/docs/2007/revisions"
         href="https://docs.google.com/feeds/default/private/full/document%3A12345/revisions"/>
  </entry>
  ...
</feed>

By default the API will return the first 100 documents and files in the user's resource list. This saves bandwidth and improves performance. To request more or less than 100 resources, use the max-results GET parameter with any resources feed URL. Valid values for this parameter are integers from 1 to 1000, inclusive.

https://docs.google.com/feeds/default/private/full?max-results=1000

To include ACL information in this feed response, replace default with expandAcl in the request URI.

https://docs.google.com/feeds/expandAcl/private/full

.NET

The following code fetches a list of the currently authenticated user's documents, and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full?showfolders=true

.NET

The following code fetches a list of the currently authenticated user's documents and collections, and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Set the showfolders parameter
      query.ShowFolders = true;

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full/-/document

.NET

The following code fetches a list of the currently authenticated user's text documents, and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a TextDocumentQuery object to retrieve text documents.
      TextDocumentQuery query = new TextDocumentQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full/-/spreadsheet

.NET

The following code fetches a list of the currently authenticated user's spreadsheets, and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a SpreadsheetQuery object to retrieve spreadsheets.
      SpreadsheetQuery query = new SpreadsheetQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full/-/presentation

.NET

The following code fetches a list of the currently authenticated user's presentations, and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a PresentationsQuery object to retrieve presentations.
      PresentationsQuery query = new PresentationsQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full/-/drawing

.NET

The following code fetches a list of the currently authenticated user's drawings, and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DrawingsQuery object to retrieve drawings.
      DrawingsQuery query = new DrawingsQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full/-/{http://schemas.google.com/g/2005#kind}application/msword

GET https://docs.google.com/feeds/default/private/full/-/%7Bhttp%3A%2F%2Fschemas.google.com%2Fg%2F2005%23kind%7Dapplication%2Fmsword

.NET

The following code fetches a list of the currently authenticated user's application/msword files, and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Add a QueryCategory corresponding to application/msword MIME type.
      query.Categories.Add(new QueryCategory(
          new AtomCategory("{http://schemas.google.com/g/2005#kind}application/msword")));

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full/-/presentation/starred

.NET

The following code fetches a list of the currently authenticated user's starred presentations, and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a PresentationsQuery object to retrieve presentations.
      PresentationsQuery query = new PresentationsQuery();

      // Set the starred category
      query.Starred = true;

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full/-/pdf/viewed

.NET

The following code fetches a list of the currently authenticated user's starred presentations, and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a PDFsQuery object to retrieve PDFs.
      PDFsQuery query = new PDFsQuery();

      // Set the viewed category
      query.Viewed = true;

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full/-/folder

.NET

The following code fetches a list of the currently authenticated user's folders, and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a FolderQuery object to retrieve folders.
      FolderQuery query = new FolderQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full/-/trashed

Trashed resources are not included by default in query results. To include them, use the showdeleted parameter:

GET https://docs.google.com/feeds/default/private/full?showdeleted=true

.NET

The following code fetches a list of the currently authenticated user's trashed documents, and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Set the trashed category
      query.Trashed = true;

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Trashed resources are not included by default in query results. To include them, use the showdeleted parameter:

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Set the showdeleted parameter
      query.ShowDeleted = true;

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full/-/pdf/mine

.NET

The following code fetches a list of the currently authenticated user's own PDFs, and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a PDFsQuery object to retrieve PDFs.
      PDFsQuery query = new PDFsQuery();

      // Set the mine category
      query.Mine = true;

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full?writer=user1%40gmail.com%2Cuser2%gmail.com

.NET

The following code fetches a list of the resources user1@mail.com and user2@gmail.com are collaborating on, and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Set the writer parameter
      query.Writer = "user1@gmail.com,user2@gmail.com";

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full?title=%22PR+Handbook%22

To match a title exactly, add the title-exact parameter:

GET https://docs.google.com/feeds/default/private/full?title=PR+Handbook&title-exact=true

.NET

The following code fetches a list of the resources matching the partial title "PR Handbook", and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Set the title parameter
      query.Title = "PR Handbook";

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

To match a title exactly, add the title-exact parameter:

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Set the title parameter
      query.Title = "PR Handbook";
      query.TitleExact = true;

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full?q=dog+cat

.NET

The following code searches the user's documents for the the words "dog" and "cat", and prints out the title of each of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Set the q parameter
      query.Query = "dog+cat";

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in feed.Entries)
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

The following example demonstrates a single HTTP request and the consequent HTTP response for creating an empty text document. The example can be applied to create other empty resources simply by changing the category of the provided resource entry.

POST [resumable-create-media link]
Content-Length: 359
Content-Type: application/atom+xml
X-Upload-Content-Length: 0

<?xml version="1.0" encoding="UTF-8"?>
<entry xmlns="http://www.w3.org/2005/Atom" xmlns:docs="http://schemas.google.com/docs/2007">
  <!-- Replace the following line appropriately to create another type of resource. -->
  <category scheme="http://schemas.google.com/g/2005#kind"
      term="http://schemas.google.com/docs/2007#document"/>
  <title>Legal Contract</title>
</entry>

The API responds with the relevant response code and the new resource entry. Clients in this scenario need not do anything further. The resource has been created.

HTTP/1.1 201 Created
ETag: "HRcET05QHyt7ImBr"
...

<?xml version="1.0" encoding="UTF-8"?>
<entry xmlns="http://www.w3.org/2005/Atom"
    xmlns:docs="http://schemas.google.com/docs/2007"
    xmlns:batch="http://schemas.google.com/gdata/batch"
    xmlns:gd="http://schemas.google.com/g/2005"
    gd:etag="&quot;HRcET05QHyt7ImBr&quot;">
  <id>https://docs.google.com/feeds/id/file%3A0B9j-hQNOVsTFZTZkMmU0Y2UtNjNmYi00Y2RkLTkwODctMTg0NzdiZDNjZTg4</id>
  <title>Legal Contract</title>
...
</entry>

.NET

The following code creates an empty text document with title "Legal Contract".

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentEntry object to be inserted.
      DocumentEntry entry = new DocumentEntry();

      // Set the document title
      entry.Title.Text = "Legal Contract";

      // Add the document category
      entry.Categories.Add(DocumentEntry.DOCUMENT_CATEGORY);

      // Make a request to the API and create the document.
      DocumentEntry newEntry = service.Insert(
          DocumentsListQuery.documentsBaseUri, entry);
    }
  }
}

Protocol

POST [resumable-create-media link]
Content-Length: 359
Content-Type: application/atom+xml
X-Upload-Content-Type: application/pdf
X-Upload-Content-Length: 1073741824

<?xml version="1.0" encoding="UTF-8"?>
<entry xmlns="http://www.w3.org/2005/Atom" xmlns:docs="http://schemas.google.com/docs/2007">
  <title>Legal Contract</title>
</entry>

HTTP/1.1 200 OK
Location: [next location]
...
PUT [next location]
Content-Length: 524288
Content-Type: application/pdf
Content-Range: bytes 0-524287/1073741824

[bytes 0-524287]
HTTP/1.1 308 Resume Incomplete
Range: 0-524287
Location: [next location]
...

After receiving each chunk, the API issues an HTTP 308 response indicating which bytes were successfully received. In the case that an HTTP 308 response is not returned, clients must resend the failed chunk to the given [next location]. An example HTTP response requiring the previous chunk to be resent is an HTTP 503.

If an HTTP 308 is received and the byte range matches that which was last sent, clients should proceed to send the next chunk.

PUT [next location]
Content-Length: 524288
Content-Type: application/pdf
Content-Range: bytes 524288-1048575/1073741824

[bytes 524288-1048575]
HTTP/1.1 308 Resume Incomplete
Range: 524288-1048575
Location: [next location]
...

Repeat the previous step, sending the next consecutive 512 kilobytes, until there are no more bytes to send. After all bytes are uploaded, the server responds with a relevant status and the new resource entry.

HTTP/1.1 201 Created
ETag: "HRcET05QHyt7ImBr"
...

<?xml version="1.0" encoding="UTF-8"?>
<entry xmlns="http://www.w3.org/2005/Atom"
    xmlns:docs="http://schemas.google.com/docs/2007"
    xmlns:batch="http://schemas.google.com/gdata/batch"
    xmlns:gd="http://schemas.google.com/g/2005"
    gd:etag=""HRcET05QHyt7ImBr"">
  <id>https://docs.google.com/feeds/id/pdf%3A0B9j-hQNOVsTFZTZkMmU0Y2UtNjNmYi00Y2RkLTkwODctMTg0NzdiZDNjZTg4</id>
  <title>Legal Contract</title>
...
</entry>

.NET

using System;
using Google.GData.Client;
using Google.GData.Client.ResumableUpload;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Instantiate an Authenticator object according to your authentication
      // mechanism (e.g. OAuth2Authenticator).
      // Authenticator authenticator =  ...

      // Instantiate a DocumentEntry object to be inserted.
      DocumentEntry entry = new DocumentEntry();

      // Set the document title
      entry.Title.Text = "Legal Contract";

      // Set the media source
      entry.MediaSource = new MediaFileSource("c:\\contract.txt", "text/plain");

      // Define the resumable upload link
      Uri createUploadUrl = new Uri("https://docs.google.com/feeds/upload/create-session/default/private/full");
      AtomLink link = new AtomLink(createUploadUrl.AbsoluteUri);
      link.Rel = ResumableUploader.CreateMediaRelation;
      entry.Links.Add(link);

      // Set the service to be used to parse the returned entry
      entry.Service = service;

      // Instantiate the ResumableUploader component.
      ResumableUploader uploader = new ResumableUploader();

      // Set the handlers for the completion and progress events
      uploader.AsyncOperationCompleted += new AsyncOperationCompletedEventHandler(OnDone);
      uploader.AsyncOperationProgress += new AsyncOperationProgressEventHandler(OnProgress);

      // Start the upload process
      uploader.InsertAsync(authenticator, entry, new object());
    }

    static void OnDone(object sender, AsyncOperationCompletedEventArgs e) {
        DocumentEntry entry = e.Entry as DocumentEntry;
    }

    static void OnProgress(object sender, AsyncOperationProgressEventArgs e) {
        int percentage = e.ProgressPercentage;
    }
  }
}

Protocol

GET https://docs.google.com/feeds/download/documents/Export?docID=0AsJD12345&exportFormat=html&format=html

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Get the download url from the resource's content element
      string downloadUrl = entry.Content.Src.Content;

      // Add the exportFormat parameter
      downloadUrl += "&exportFormat=html&format=html";

      // Download the document as a stream
      Stream stream = service.Query(new Uri(downloadUrl));
    }
  }
}

Protocol

GET https://docs.google.com/feeds/download/drawings/Export?docID=0AsJD12345&exportFormat=jpeg

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Get the download url from the resource's content element
      string downloadUrl = entry.Content.Src.Content;

      // Add the exportFormat parameter
      downloadUrl += "&exportFormat=jpeg";

      // Download the document as a stream
      Stream stream = service.Query(new Uri(downloadUrl));
    }
  }
}

Protocol

GET https://docs.google.com/feeds/download/presentations/Export?docID=0AsJD12345&exportFormat=png

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Get the download url from the resource's content element
      string downloadUrl = entry.Content.Src.Content;

      // Add the exportFormat parameter
      downloadUrl += "&exportFormat=png";

      // Download the document as a stream
      Stream stream = service.Query(new Uri(downloadUrl));
    }
  }
}

Protocol

GET https://spreadsheets.google.com/feeds/download/spreadsheets/Export?key=0AsJD12345&exportFormat=csv

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Get the download url from the resource's content element
      string downloadUrl = entry.Content.Src.Content;

      // Add the exportFormat parameter
      downloadUrl += "&exportFormat=csv";

      // Download the document as a stream
      Stream stream = service.Query(new Uri(downloadUrl));
    }
  }
}

Protocol

GET https://spreadsheets.google.com/feeds/download/spreadsheets/Export?key=0AsJD12345&exportFormat=csv&gid=1

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Get the download url from the resource's content element
      string downloadUrl = entry.Content.Src.Content;

      // Add the exportFormat parameter
      downloadUrl += "&exportFormat=csv";

      // Add the gid parameter
      downloadUrl += "&gid=1";

      // Download the document as a stream
      Stream stream = service.Query(new Uri(downloadUrl));
    }
  }
}

Protocol

GET https://doc-04-20-docs.googleusercontent.com/docs/secure/m7an0emtau/WJm12345/YzI2Y2ExYWVm?h=16655626&e=download&gd=true

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Get the download url from the resource's content element
      string downloadUrl = entry.Content.Src.Content;

      // Download the file as a stream
      Stream stream = service.Query(new Uri(downloadUrl));
    }
  }
}

Protocol

PUT https://docs.google.com/feeds/default/private/full/spreadsheet%3A0Aj12345
Authorization: <your authorization header here>
Content-Length: 292
Content-Type: application/atom+xml

<?xml version='1.0' encoding='UTF-8'?>
<entry xmlns="http://www.w3.org/2005/Atom" xmlns:docs="http://schemas.google.com/docs/2007"
    xmlns:gd="http://schemas.google.com/g/2005" gd:etag="BxAaTxRZAyp7ImBq">
  <title>example spreadsheet</title>
  <docs:writersCanInvite value="true" />
</entry>

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Update the document's title
      entry.Title.Text = "example spreadsheet";

      // Allow collaborators to share the document with users
      entry.WritersCanInvite = true;

      // Make a request to the API and update the document.
      entry.Update();
    }
  }
}

Protocol

Here is the initial request:

PUT https://docs.google.com/feeds/upload/create-session/default/private/full/document%3A12345
Authorization: <your authorization header here>
If-Match: <ETag or * here>
Content-Length: 1000
Content-Type: text/plain
X-Upload-Content-Length: 1000
X-Upload-Content-Type: text/plain

<empty body>

To update a resource's metadata and content at the same time, include Atom XML instead of an empty body. See the example in the Initiating a resumable upload request section.

When the server responds with the unique upload URI, send a PUT with your payload. Once the unique upload URI is fetched, the process for updating the file's content is the same as uploading a file.

This is an example of updating an existing document's content all at once:

PUT <upload_uri>
Content-Length: 1000
Content-Range: 0-999/1000

<bytes 0-999>

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Instantiate an Authenticator object according to your authentication
      // mechanism (e.g. OAuth2Authenticator).
      // Authenticator authenticator =  ...

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Update the document's title
      entry.Title.Text = "example spreadsheet";

      // Set the media source
      entry.MediaSource = new MediaFileSource("c:\\new_contract.txt", "text/plain");

      // Instantiate the ResumableUploader component.
      ResumableUploader uploader = new ResumableUploader();

      // Set the handlers for the completion and progress events
      uploader.AsyncOperationCompleted += new AsyncOperationCompletedEventHandler(OnDone);
      uploader.AsyncOperationProgress += new AsyncOperationProgressEventHandler(OnProgress);

      // Start the update process.
      uploader.UpdateAsync(authenticator, entry, new object());
    }

    static void OnDone(object sender, AsyncOperationCompletedEventArgs e) {
        DocumentEntry entry = e.Entry as DocumentEntry;
    }

    static void OnProgress(object sender, AsyncOperationProgressEventArgs e) {
        int percentage = e.ProgressPercentage;
    }
  }
}

Protocol

To fetch the revision history for an item, send an HTTP GET to the which has the rel attribute of http://schemas.google.com/docs/2007/revisions:

GET https://docs.google.com/feeds/default/private/full/resource_id/revisions
Authorization: <your authorization header here>

<feed xmlns="http://www.w3.org/2005/Atom" xmlns:openSearch="http://a9.com/-/spec/opensearch/1.1/"
    xmlns:batch="http://schemas.google.com/gdata/batch" xmlns:gd="http://schemas.google.com/g/2005"
    xmlns:docs="http://schemas.google.com/docs/2007"
    gd:etag="W/&quot;CE4HQX08cCt7ImA9WxNTFEU.&quot;">
<id>https://docs.google.com/feeds/default/private/full/resource_id/revisions</id>
<updated>2009-08-17T04:22:10.378Z</updated>
<title>Document Revisions</title>
<link rel="http://schemas.google.com/g/2005#feed" type="application/atom+xml"
    href="https://docs.google.com/feeds/default/private/full/resource_id/revisions"/>
<link rel="http://schemas.google.com/g/2005#batch" type="application/atom+xml"
    href="https://docs.google.com/feeds/default/private/full/resource_id/revisions/batch"/>
<link rel="self" type="application/atom+xml"
    href="https://docs.google.com/feeds/default/private/full/resource_id/revisions"/>
<openSearch:totalResults>6</openSearch:totalResults>
<openSearch:startIndex>1</openSearch:startIndex>
<entry>
  <id>https://docs.google.com/feeds/id/resource_id/revisions/0</id>
  <updated>2009-08-17T04:22:10.440Z</updated>
  <app:edited xmlns:app="http://www.w3.org/2007/app">2009-08-06T03:25:07.798Z</app:edited>
  <title>Revision 0</title>
  <content type="text/html" src="https://docs.google.com/feeds/download/documents/Export?docId=doc_id&amp;revision=0"/>
  <link rel="alternate" type="text/html"
      href="https://docs.google.com/Doc?id=doc_id&amp;revision=0"/>
  <link rel="self" type="application/atom+xml"
      href="https://docs.google.com/feeds/default/private/full/resource_id/revisions/0"/>
  <author>
    <name>user</name>
    <email>user@gmail.com</email>
  </author>
</entry>
<entry>
  <id>https://docs.google.com/feeds/id/resource_id/revisions/1</id>
  <updated>2009-08-17T04:22:10.440Z</updated>
  <app:edited xmlns:app="http://www.w3.org/2007/app">2009-08-06T03:25:07.799Z</app:edited>
  <title>Revision 1</title>
  <content type="text/html" src="https://docs.google.com/feeds/download/documents/Export?docId=doc_id&amp;revision=1"/>
  <link rel="alternate" type="text/html"
      href="https://docs.google.com/Doc?id=doc_id&amp;revision=1"/>
  <link rel="self" type="application/atom+xml"
      href="https://docs.google.com/feeds/default/private/full/resource_id/revisions/1"/>
  <author>
    <name>user</name>
    <email>user@gmail.com</email>
  </author>
</entry>
<entry>
  <id>https://docs.google.com/feeds/id/resource_id/revisions/2</id>
  <updated>2009-08-17T04:22:10.440Z</updated>
  <app:edited xmlns:app="http://www.w3.org/2007/app">2009-08-14T07:11:34.197Z</app:edited>
  <title>Revision 2</title>
  <content type="text/html" src="https://docs.google.com/feeds/download/documents/Export?docId=doc_id&amp;revision=2"/>
  <link rel="alternate" type="text/html"
      href="https://docs.google.com/Doc?id=doc_id&amp;revision=2"/>
  <link rel="self" type="application/atom+xml"
      href="https://docs.google.com/feeds/default/private/full/resource_id/revisions/2"/>
  <link rel="http://schemas.google.com/docs/2007#publish" type="text/html"
      href="https://docs.google.com/View?docid=doc_id&pageview=1&hgd=1"/>
  <author>
    <name>another_user</name>
    <email>another_user@gmail.com</email>
  </author>
  <docs:publish value="true"/>
  <docs:publishAuto value="true"/>
  <docs:publishOutsideDomain value="false"/>
</entry>
</feed>

.NET

The following code fetches the list of revision for the first document in a feed. It first prints out the title of the document, and then prints a list of all revisions of that document.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];
      Console.WriteLine(entry.Title.Text);

      // Instantiate a RevisionQuery object to retrieve revisions.
      RevisionQuery revisionQuery = new RevisionQuery(entry.RevisionDocument);

      // Make a request to the API and get all revisions.
      RevisionFeed revisions = service.Query(revisionQuery);

      // Iterate through all of the revisions returned
      foreach (RevisionEntry revision in revisions.Entries)
      {
        // Print the title of this revision to the screen
        Console.WriteLine(revision.Title.Text);
        Console.WriteLine(revision.Publish);
        foreach (AtomPerson author in revision.Authors)
        {
            // Print the name of each revision's author to the screen
            Console.WriteLine(author.Name);
        }
      }
    }
  }
}

Protocol

GET https://docs.google.com/feeds/download/documents/Export?docId=doc_id&revision=2&exportFormat=txt
Authorization: <your authorization header here>

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Get the download url from the resource's content element
      string downloadUrl = entry.Content.Src.Content;

      // Add the exportFormat parameter
      downloadUrl += "&exportFormat=txt";

      // Add the revision parameter
      downloadUrl += "&revision=2";

      // Download the document as a stream
      Stream stream = service.Query(new Uri(downloadUrl));
    }
  }
}

Protocol

DELETE https://docs.google.com/feeds/default/private/full/resource_id/revisions/revision_id
Authorization: <your authorization header here>

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Instantiate a RevisionQuery object to retrieve revisions.
      RevisionQuery revisionQuery = new RevisionQuery(entry.RevisionDocument);

      // Make a request to the API and get all revisions.
      RevisionFeed revisions = service.Query(revisionQuery);

      if (revisions.Entries.Count == 0)
      {
        // TODO: There were no revisions, act accordingly.
      }

      // TODO: Choose a revision based on your app's needs.
      RevisionEntry revision = (RevisionEntry)revisions.Entries[0];

      // Make a request to the API and delete the revision.
      revision.Delete();
    }
  }
}

Protocol

PUT https://docs.google.com/feeds/default/private/full/resource_id/revisions/revision_number
Authorization: <your authorization header here>
Content-Length: 722
Content-Type: application/atom+xml

<entry xmlns="http://www.w3.org/2005/Atom" xmlns:gd='http://schemas.google.com/g/2005'
       xmlns:docs="http://schemas.google.com/docs/2007" gd:etag="W/"DkIBR3st7ImA9WxNbF0o."">
  <id>https://docs.google.com/feeds/id/resource_id/revisions/1</id>
  <updated>2009-08-17T04:22:10.440Z</updated>
  <app:edited xmlns:app="http://www.w3.org/2007/app">2009-08-06T03:25:07.799Z</app:edited>
  <title>Revision 1</title>
  <content type="text/html" src="https://docs.google.com/feeds/download/documents/Export?docId=doc_id&amp;revision=1"/>
  <link rel="alternate" type="text/html"
      href="https://docs.google.com/Doc?id=doc_id&amp;revision=1"/>
  <link rel="self" type="application/atom+xml"
      href="https://docs.google.com/feeds/default/private/full/resource_id/revisions/1"/>
  <author>
    <name>user</name>
    <email>user@gmail.com</email>
  </author>
  <docs:publish value="true"/>
  <docs:publishAuto value="false"/>
</entry>

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Instantiate a RevisionQuery object to retrieve revisions.
      RevisionQuery revisionQuery = new RevisionQuery(entry.RevisionDocument);

      // Make a request to the API and get all revisions.
      RevisionFeed revisions = service.Query(revisionQuery);

      if (revisions.Entries.Count == 0)
      {
        // TODO: There were no revisions, act accordingly.
      }

      // TODO: Choose a revision based on your app's needs.
      RevisionEntry revision = (RevisionEntry)revisions.Entries[0];

      // Change the publishing settings.
      revision.Publish = true;
      revision.PublishAuto = true;

      // Make a request to the API and update the revision.
      revision.Update();
    }
  }
}

Protocol

This example uses the self link of the source entry:

POST https://docs.google.com/feeds/default/private/full
Authorization: <your authorization header here>
Content-Length: 292
Content-Type: application/atom+xml

<?xml version='1.0' encoding='UTF-8'?>
<entry xmlns="http://www.w3.org/2005/Atom">
  <id>https://docs.google.com/feeds/default/private/full/document:12345</id>
  <title>My Copy</title>
</entry>

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry source = (DocumentEntry)feed.Entries[0];

      // Instantiate a DocumentEntry object to be inserted.
      DocumentEntry entry = new DocumentEntry();

      // Set the document title
      entry.Title.Text = "Copy of Legal Contract";

      // Copy the resource ID of the source document
      entry.Id = source.Id;

      // Make a request to the API and copy the document.
      entry = service.Insert(DocumentsListQuery.documentsBaseUri, entry);
    }
  }
}

Protocol

DELETE https://docs.google.com/feeds/default/private/full/resource_id
If-Match: <ETag or * here>
Authorization: <your authorization header here>

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Make a request to the API and trash the document.
      service.Delete(entry);
    }
  }
}

Protocol

DELETE https://docs.google.com/feeds/default/private/full/resource_id?delete=true
If-Match: <ETag or * here>
Authorization: <your authorization header here>

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Make a request to the API and delete the document.
      service.Delete(entry, true);
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full?showroot=true
Authorization: <your authorization header here>

This will cause the API to return a feed of resources that looks something like:

<entry xmlns:gd="http://schemas.google.com/g/2005" gd:etag="'HhJSFgpeRyt7ImBq'">
  ...
  <title>PDF's Title</title>
  ...
</entry>
<entry xmlns:gd="http://schemas.google.com/g/2005" gd:etag="'HhJSFgpeRyt7ImBq'">
  ...
  <title>PDF's Title</title>
  ...
  <link rel="http://schemas.google.com/docs/2007#parent"
      type="application/atom+xml"
      href="https://docs.google.com/feeds/default/private/full/folder%3Aroot"
      title="My items"/>
  ...
</entry>
...

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Set the ShowRoot parameter.
      query.ShowRoot = true;

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full/folder%3Acollection_id/contents
Authorization: <your authorization header here>

The feed of a collection's contents will look something like this:

<feed xmlns="http://www.w3.org/2005/Atom" xmlns:openSearch="http://a9.com/-/spec/opensearch/1.1/"
    xmlns:docs="http://schemas.google.com/docs/2007" xmlns:batch="http://schemas.google.com/gdata/batch" xmlns:gd="http://schemas.google.com/g/2005"
    gd:etag="W/&quot;DkQDQH4_eSt7ImA9WxNTEkw.&quot;">

<!-- Unique identifier of this feed.  Not unique between users. -->
<id>https://docs.google.com/feeds/default/private/full/folder%3A0B9kQ4KIBsdfYzNmNiMjI4N/contents</id>

<!-- Date this collection's contents were last updated.  Do NOT use this, provided for Atom compliance only. -->
<updated>2009-08-14T01:46:11.041Z</updated>

<!-- Title of this feed result. -->
<title>Available Documents - john.smith.example@gmail.com</title>

<!-- Link at which a user could see this collection's contents in a web browser. -->
<link rel="alternate" type="text/html" href="https://docs.google.com/#folders/folder.0.0B9kQ4KIBsdfYzNmNiMjI4N"/>

<!-- Link at which you can fetch this same feed. -->
<link rel="self" type="application/atom+xml"
    href="https://docs.google.com/feeds/default/private/full/folder%3A0B9kQ4KIBsdfYzNmNiMjI4N/contents"/>

<!-- Link at which you can fetch this same feed. -->
<link rel="http://schemas.google.com/g/2005#feed" type="application/atom+xml"
    href="https://docs.google.com/feeds/default/private/full/folder%3A0B9kQ4KIBsdfYzNmNiMjI4N/contents"/>

<!-- Link at which you can POST new entries with metadata only to this feed (e.g. to add items to this collection). -->
<link rel="http://schemas.google.com/g/2005#post" type="application/atom+xml"
    href="https://docs.google.com/feeds/default/private/full/folder%3A0B9kQ4KIBsdfYzNmNiMjI4N/contents"/>

<!-- Link at which you can send batch requests to this feed.  NOT supported by Documents List API, provided for GData compliance. -->
<link rel="http://schemas.google.com/g/2005#batch" type="application/atom+xml"
    href="https://docs.google.com/feeds/default/private/full/folder%3A0B9kQ4KIBsdfYzNmNiMjI4N/contents/batch"/>

<!-- Information about the owner of this collection. -->
<author>
  <name>John Smith</name>
  <email>john.smith.example@gmail.com</email>
</author>

<!-- NOT supported, provided for protocol compliance only. -->
<openSearch:startIndex>1</openSearch:startIndex>

<entry gd:etag=""BEFd33dgfImBr"">
  <id>https://docs.google.com/feeds/id/document%3A1j8yrZUCg234gdsgaxcz7tyBDHsy_vZeUfXfZNAffHatXXqk</id>
  <published>2011-04-13T10:44:28.877Z</published>
  <updated>2011-04-13T10:44:29.253Z</updated>
  <app:edited xmlns:app="http://www.w3.org/2007/app">2011-04-13T10:44:30.113Z</app:edited>
  <category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/docs/2007#document" label="document"/>
  <category scheme="http://schemas.google.com/g/2005/labels" term="http://schemas.google.com/g/2005/labels#viewed" label="viewed"/>
  <title>My document</title>
  <content type="text/html" src="https://docs.google.com/feeds/download/documents/export/Export?id=1j8yrZUCg234gdsgaxcz7tyBDHsy_vZeUfXfZNAffHatXXqk"/>
  <link rel="http://schemas.google.com/docs/2007#parent" type="application/atom+xml" href="https://docs.google.com/feeds/default/private/full/folder%3A0B9kQ4KIBsdfYzNmNiMjI4N" title="Example Folder"/>
  <link rel="alternate" type="text/html" href="https://docs.google.com/a/google.com/document/d/1j8yrZUCg234gdsgaxcz7tyBDHsy_vZeUfXfZNAffHatXXqk/edit?hl=en"/>
  <link rel="http://schemas.google.com/g/2005#resumable-edit-media" type="application/atom+xml" href="https://docs.google.com/feeds/upload/create-session/default/private/full/document%3A1j8yrZUCg234gdsgaxcz7tyBDHsy_vZeUfXfZNAffHatXXqk"/>
  <link rel="http://schemas.google.com/docs/2007/thumbnail" type="image/jpeg" href="https://lh6.googleusercontent.com/q78pafbgaRCrpzxcbdfgw437h4o-Jqv1s5MS7vwaIBfWxMSXIEg9-geu2g73EvvV5oiTlunjpnf9H0OQ=s220"/>
  <link rel="self" type="application/atom+xml" href="https://docs.google.com/feeds/default/private/full/folder%3A0B9kQ4KIBsdfYzNmNiMjI4N/contents/document%3A1j8yrZUCgmanua9Rz7tyBDHsy_vZeUfXfZNAzHatXXqk"/>
  <link rel="edit" type="application/atom+xml" href="https://docs.google.com/feeds/default/private/full/folder%3A0B9kQ4KIBsdfYzNmNiMjI4N/contents/document%3A1j8yrZUCgmanua9Rz7tyBDHsy_vZeUfXfZNAzHatXXqk"/>
  <link rel="edit-media" type="text/html" href="https://docs.google.com/feeds/default/contentmedia/folder%3A0B9kQ4KIBsdfYzNmNiMjI4N/document%3A1j8yrZUCgmanua9Rz7tyBDHsy_vZeUfXfZNAzHatXXqk"/>
  <author>
    <name>user</name>
    <email>user@gmail.com</email>
  </author>
  <gd:resourceId>document:1j8yrZUCg234gdsgaxcz7tyBDHsy_vZeUfXfZNAffHatXXqk</gd:resourceId>
  <gd:lastModifiedBy>
    <name>user</name>
    <email>user@gmak..com</email>
  </gd:lastModifiedBy>
  <gd:lastViewed>2011-04-13T10:44:29.253Z</gd:lastViewed>
  <gd:quotaBytesUsed>0</gd:quotaBytesUsed>
  <docs:writersCanInvite value="true"/>
  <gd:feedLink rel="http://schemas.google.com/acl/2007#accessControlList" href="https://docs.google.com/feeds/default/private/full/document%3A1j8yrZUCgmanua9Rz7tyBDHsy_vZeUfXfZNAzHatXXqk/acl"/>
  <gd:feedLink rel="http://schemas.google.com/docs/2007/revisions" href="https://docs.google.com/feeds/default/private/full/document%3A1j8yrZUCgmanua9Rz7tyBDHsy_vZeUfXfZNAzHatXXqk/revisions"/>
</entry>

...
</feed>

.NET

The following code fetches a list of the currently authenticated user's folders, then prints out the content of the first of them.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a FolderQuery object to retrieve folders.
      FolderQuery query = new FolderQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no folders, act accordingly.
      }

      // TODO: Choose a folder based on your app's needs.
      DocumentEntry folder = (DocumentEntry)feed.Entries[0];

      // Instantiate a FolderQuery object to retrieve the content of the folder.
      FolderQuery contentQuery = new FolderQuery(folder.ResourceId);

      // Make a request to the API and get the folder contents.
      DocumentsFeed contents = service.Query(contentQuery);

      // Iterate through all of the documents returned
      foreach (DocumentEntry entry in contents.Entries) {
      {
        // Print the title of this document to the screen
        Console.WriteLine(entry.Title.Text);
        Console.WriteLine(entry.Title.Text);
      }
    }
  }
}

Protocol

POST https://docs.google.com/feeds/default/private/full
Authorization: <your authorization header here>
Content-Length: 245
Content-Type: application/atom+xml

<?xml version='1.0' encoding='UTF-8'?>
<entry xmlns="http://www.w3.org/2005/Atom">
  <category scheme="http://schemas.google.com/g/2005#kind"
      term="http://schemas.google.com/docs/2007#folder"/>
  <title>Example Collection</title>
</entry>

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentEntry object to be inserted.
      DocumentEntry folder = new DocumentEntry();

      // Set the folder category.
      folder.IsFolder = true;

      // Set the folder title.
      folder.Title.Text = "Example Collection";

      // Make a request to the API and create the folder.
      DocumentEntry newFolder = service.Insert(DocumentsListQuery.documentsBaseUri, folder);
    }
  }
}

Protocol

POST https://docs.google.com/feeds/default/private/full/folder%3Acollection_id/contents
Authorization: <your authorization header here>
Content-Length: 244
Content-Type: application/atom+xml

<?xml version='1.0' encoding='UTF-8'?>
<entry xmlns="http://www.w3.org/2005/Atom">
  <category scheme="http://schemas.google.com/g/2005#kind"
      term="http://schemas.google.com/docs/2007#folder"/>
  <title>New subcollection</title>
</entry>

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a FolderQuery object to retrieve folders.
      FolderQuery query = new FolderQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no folders, act accordingly.
      }

      // TODO: Choose a folder based on your app's needs.
      DocumentEntry folder = (DocumentEntry)feed.Entries[0];

      // Instantiate a FolderQuery object to retrieve the content of the folder.
      FolderQuery contentQuery = new FolderQuery(folder.ResourceId);

      // Instantiate a DocumentEntry object to be inserted.
      DocumentEntry subfolder = new DocumentEntry();

      // Set the folder category.
      subfolder.IsFolder = true;

      // Set the folder title.
      subfolder.Title.Text = "Example Collection";

      // Make a request to the API and create the subfolder.
      DocumentEntry newFolder = service.Insert(contentQuery.Uri, subfolder);
    }
  }
}

Protocol

POST https://docs.google.com/feeds/default/private/full/folder%3Adestination_collection_id/contents
Authorization: <your authorization header here>
Content-Length: 180
Content-Type: application/atom+xml

<?xml version='1.0' encoding='UTF-8'?>
<entry xmlns="http://www.w3.org/2005/Atom">
  <id>https://docs.google.com/feeds/default/private/full/document:1234abcd</id>
</entry>

.NET

The following code copies the first of the currently authenticated user's documents into the first folder.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a FolderQuery object to retrieve folders.
      FolderQuery folderQuery = new FolderQuery();

      // Make a request to the API and get all folder.
      DocumentsFeed folderFeed = service.Query(folderQuery);

      if (folderFeed.Entries.Count == 0)
      {
        // TODO: There were no folders, act accordingly.
      }

      // TODO: Choose a folder based on your app's needs.
      DocumentEntry folder = (DocumentEntry)folderFeed.Entries[0];

      // Instantiate a FolderQuery object to retrieve the content of the folder.
      FolderQuery contentQuery = new FolderQuery(folder.ResourceId);

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a document based on your app's needs.
      DocumentEntry source = (DocumentEntry)feed.Entries[0];

      // Instantiate a DocumentEntry object to be inserted.
      DocumentEntry entry = new DocumentEntry();

      // Copy the resource ID of the source document
      entry.Id = source.Id;

      // Make a request to the API and copy the document into the folder.
      entry = service.Insert(contentQuery.Uri, entry);
    }
  }
}

Protocol

DELETE https://docs.google.com/feeds/default/private/full/folder%3Acollection_id/contents/resource_id
Authorization: <your authorization header here>

.NET

The following code removes the first document from the first of the currently authenticated user's folders.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a FolderQuery object to retrieve folders.
      FolderQuery folderQuery = new FolderQuery();

      // Make a request to the API and get all folder.
      DocumentsFeed folderFeed = service.Query(folderQuery);

      if (folderFeed.Entries.Count == 0)
      {
        // TODO: There were no folders, act accordingly.
      }

      // TODO: Choose a folder based on your app's needs.
      DocumentEntry folder = (DocumentEntry)folderFeed.Entries[0];

      // Instantiate a FolderQuery object to retrieve the content of the folder.
      FolderQuery contentQuery = new FolderQuery(folder.ResourceId);

      // Make a request to the API and get the folder contents.
      DocumentsFeed contentFeed = service.Query(contentQuery);

      if (contentFeed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a document based on your app's needs.
      DocumentEntry entry = (DocumentEntry)contentFeed.Entries[0];

      // Make a request to the API and remove the document from the folder.
      entry.Delete();
    }
  }
}

Protocol

DELETE https://docs.google.com/feeds/default/private/full/folder:12345
If-Match: <ETag or * here>

.NET

The following code removes the first of the currently authenticated user's folders.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a FolderQuery object to retrieve folders.
      FolderQuery query = new FolderQuery();

      // Make a request to the API and get all folder.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no folders, act accordingly.
      }

      // TODO: Choose a folder based on your app's needs.
      DocumentEntry folder = (DocumentEntry)feed.Entries[0];

      service.Delete(folder);
    }
  }
}

Protocol

DELETE https://docs.google.com/feeds/default/private/full/resource_id?delete=true
If-Match: <ETag or * here>

.NET

The following code removes the first of the currently authenticated user's folders.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a FolderQuery object to retrieve folders.
      FolderQuery query = new FolderQuery();

      // Make a request to the API and get all folder.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no folders, act accordingly.
      }

      // TODO: Choose a folder based on your app's needs.
      DocumentEntry folder = (DocumentEntry)feed.Entries[0];

      service.Delete(folder, true);
    }
  }
}

Protocol

GET https://docs.google.com/feeds/default/private/full/resource_id/acl
Authorization: <your authorization header here>

The XML snippet below shows the ACL feed for the example document. Note that the feed contains three ACL entries. The element of each ACL entry ends with the email address of the specific user that the ACL entry corresponds to:

document.owner@example.com

the ACL entry for the document's owner

a.writer@example.com

the ACL entry for a collaborator

a.reader@example.com

the ACL entry for a reader that can also comment

<?xml version='1.0' encoding='utf-8'?>
<feed xmlns='http://www.w3.org/2005/Atom'
    xmlns:openSearch='http://a9.com/-/spec/opensearch/1.1/'
    xmlns:gAcl='http://schemas.google.com/acl/2007'
    xmlns:gd='http://schemas.google.com/g/2005'
    gd:etag='W/"CUUNSXYyfCp7ImA9WxRVGUo."'>
  <id>https://docs.google.com/feeds/default/private/full/document%3Adocument_id/acl</id>
  <updated>2008-09-03T22:03:04.733Z</updated>
  <category scheme='http://schemas.google.com/g/2005#kind' term='http://schemas.google.com/acl/2007#accessRule' />
  <title type='text'>Document Permissions</title>
  <link rel='http://schemas.google.com/g/2005#feed' type='application/atom+xml'
  href='https://docs.google.com/feeds/default/private/full/document%3Adocument_id/acl' />
  <link rel='http://schemas.google.com/g/2005#post' type='application/atom+xml'
  href='https://docs.google.com/feeds/default/private/full/document%3Adocument_id/acl' />
  <link rel='self' type='application/atom+xml'
  href='https://docs.google.com/feeds/default/private/full/document%3Adocument_id/acl' />
  <openSearch:totalResults>3</openSearch:totalResults>
  <openSearch:startIndex>1</openSearch:startIndex>
  <entry gd:etag='W/"CUUNSXYyfCp7ImA9WxRVGUo."'>
    <id>https://docs.google.com/feeds/default/private/full/document%3Adocument_id/acl/user%3Adocument.owner%40example.com</id>
    <updated>2008-09-03T22:03:04.756Z</updated>
    <category scheme='http://schemas.google.com/g/2005#kind' term='http://schemas.google.com/acl/2007#accessRule' />
    <title type='text'>Document Permission - document.owner@example.com</title>
    <link rel='self' type='application/atom+xml'
    href='https://docs.google.com/feeds/default/private/full/document%3Adocument_id/acl/user%3Adocument.owner%40example.com' />
    <link rel='edit' type='application/atom+xml'
    href='https://docs.google.com/feeds/default/private/full/document%3Adocument_id/acl/user%3Adocument.owner%40example.com' />
    <gAcl:role value='owner' />
    <gAcl:scope type='user' value='document.owner@example.com' />
  </entry>
  <entry gd:etag='W/"CUMFQnc4fip7ImA9WxRVGUo."'>
    <id>https://docs.google.com/feeds/default/private/full/document%3Adocument_id/acl/user%3Aa.writer%40example.com<>
    <updated>2008-09-03T22:03:04.762Z</updated>
    <category scheme='http://schemas.google.com/g/2005#kind' term='http://schemas.google.com/acl/2007#accessRule' />
    <title type='text'>Document Permission - a.writer@example.com</title>
    <link rel='self' type='application/atom+xml'
    href='https://docs.google.com/feeds/default/private/full/document%3Adocument_id/acl/user%3Aa.writer%40example.com' />
    <link rel='edit' type='application/atom+xml'
    href='https://docs.google.com/feeds/default/private/full/document%3Adocument_id/acl/user%3Aa.writer%40example.com' />
    <gAcl:role value='writer' />
    <gAcl:scope type='user' value='a.writer@example.com' />
  </entry>
  <entry gd:etag='W/"CUMASXg8fCp7ImA9WxRVGUo."'>
    <id>https://docs.google.com/feeds/default/private/full/document%3Adocument_id/acl/user%3Aa.reader%40example.com</id>
    <updated>2008-09-03T22:03:04.763Z</updated>
    <category scheme='http://schemas.google.com/g/2005#kind' term='http://schemas.google.com/acl/2007#accessRule' />
    <title type='text'>Document Permission - a.reader@example.com</title>
    <link rel='self' type='application/atom+xml'
    href='https://docs.google.com/feeds/default/private/full/document%3Adocument_id/acl/user%3Aa.reader%40example.com' />
    <link rel='edit' type='application/atom+xml'
    href='https://docs.google.com/feeds/default/private/full/document%3Adocument_id/acl/user%3Aa.reader%40example.com' />
    <gAcl:role value='reader'/>
    <gAcl:additionalRole value='commenter'/>
    <gAcl:scope type='user' value='a.reader@example.com' />
  </entry>
</feed>

.NET

The following code fetches a list of the currently authenticated user's documents, and prints out the ACLs of the first of them.

using System;
using Google.GData.AccessControl;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Instantiate a AclQuery object to retrieve ACLs.
      AclQuery aclQuery = new AclQuery(entry.AccessControlList);

      // Make a request to the API and get all ACLs for the document.
      AclFeed aclFeed = service.Query(aclQuery);

      // Iterate through all of the ACLs returned
      foreach (AclEntry acl in aclFeed.Entries)
      {
        // Print the acl Role to the screen
        Console.WriteLine(acl.Role.Value);
        // Print the acl Scope type and value to the screen
        Console.WriteLine(acl.Scope.Type + " - " + acl.Scope.Value);
      }
    }
  }
}

Protocol

The example below shows how to share a document with a single collaborator:

POST https://docs.google.com/feeds/default/private/full/resource_id/acl
Authorization: <your authorization header here>

<entry xmlns="http://www.w3.org/2005/Atom" xmlns:gAcl='http://schemas.google.com/acl/2007'>
  <category scheme='http://schemas.google.com/g/2005#kind'
    term='http://schemas.google.com/acl/2007#accessRule'/>
  <gAcl:role value='writer'/>
  <gAcl:scope type='user' value='new_writer@example.com'/>
</entry>

The new entry is returned on a successful insertion:

201 Created

<entry gd:etag='W/"CUUNSXYyfCp7ImA9WxRVGUo."'>
  <id>https://docs.google.com/feeds/default/private/full/document:1234abcd/acl/user:new_writer@example.com</id>
  <updated>2008-09-11T03:10:00.913Z</updated>
  <category scheme='http://schemas.google.com/g/2005#kind'
        term='http://schemas.google.com/acl/2007#accessRule'/>
  <title type='text'>Document Permission - new_writer@example.com</title>
  <link rel='self' type='application/atom+xml'
        href='https://docs.google.com/feeds/acl/private/full/document:1234abcd/acl/user:new_writer@example.com'/>
  <link rel='edit' type='application/atom+xml'
        href='https://docs.google.com/feeds/acl/private/full/document:1234abcd/acl/user:new_writer@example.com'/>
  <gAcl:role value='writer'/>
  <gAcl:scope type='user' value='new_writer@example.com'/>
</entry>

.NET

The following code shares the first document in the feed with a single collaborator.

using System;
using Google.GData.AccessControl;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Instantiate a AclEntry object to update sharing permissions.
      AclEntry acl = new AclEntry();

      // Set the ACL scope.
      acl.Scope = new AclScope("new_writer@example.com", "user");

      // Set the ACL role.
      acl.Role = new AclRole("writer");

      // Insert the new role into the ACL feed.
      service.Insert(new Uri(entry.AccessControlList), acl);
    }
  }
}

Protocol

PUT https://docs.google.com/feeds/default/private/full/document:1234abcd/acl/user:new_writer@example.com

<entry xmlns="http://www.w3.org/2005/Atom" xmlns:gAcl='http://schemas.google.com/acl/2007'
       xmlns:gd='http://schemas.google.com/g/2005'
       gd:etag='W/"CUUNSXYyfCp7ImA9WxRVGUo."'>
  <category scheme='http://schemas.google.com/g/2005#kind' term='http://schemas.google.com/acl/2007#accessRule'/>
  <gAcl:role value='reader'/>
  <gAcl:additionalRole value='commenter'/>
  <gAcl:scope type='user' value='new_writer@gmail.com'/>
</entry>

.NET

The following code fetches a list of the currently authenticated user's documents, and changes the ACL's role of the first of them.

using System;
using Google.GData.AccessControl;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Instantiate a AclQuery object to retrieve ACLs.
      AclQuery aclQuery = new AclQuery(entry.AccessControlList);

      // Make a request to the API and get all ACLs for the document.
      AclFeed aclFeed = service.Query(aclQuery);

      // TODO: Choose a ACL based on your app's needs.
      AclEntry acl = (AclEntry)aclFeed.Entries[0];

      // Change the ACL's role.
      acl.Role = new AclRole("reader");

      // Update the ACL entry.
      acl.Update();
    }
  }
}

Protocol

DELETE https://docs.google.com/feeds/default/private/full/resource_id/acl/user:new_writer@example.com
Authorization: <your authorization header here>

.NET

The following code fetches a list of the currently authenticated user's documents, and deletes the first ACL of the first document.

using System;
using Google.GData.AccessControl;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Instantiate a AclQuery object to retrieve ACLs.
      AclQuery aclQuery = new AclQuery(entry.AccessControlList);

      // Make a request to the API and get all ACLs for the document.
      AclFeed aclFeed = service.Query(aclQuery);

      // TODO: Choose a ACL based on your app's needs.
      AclEntry acl = (AclEntry)aclFeed.Entries[0];

      // Delete the ACL entry.
      acl.Delete();
    }
  }
}

Protocol

<entry>
  <gAcl:withKey key='[ACL KEY]'><gAcl:role value='writer' /></gAcl:withKey>
  <gAcl:scope type='domain' value='example.com' />
</entry>

.NET

The following code shares the first document in the feed with all domain users who have the specified key, and gives those users write permission.

using System;
using Google.GData.AccessControl;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Instantiate a AclEntryWithKey object to share with keys.
      AclEntryWithKey acl = new AclEntryWithKey();

      // Set the ACL scope.
      acl.Scope = new AclScope("example.com", "domain");

      // Instantiate a AclWithKey object to specify a key.
      AclWithKey withKey = new AclWithKey("[ACL KEY]");

      // Set the ACL role.
      withKey.Role = new AclRole("writer");

      // Set the WithKey property of the AclEntryWithKey element.
      acl.WithKey = withKey;

      // Insert the new role into the ACL feed.
      service.Insert(new Uri(entry.AccessControlList), acl);
    }
  }
}

Protocol

<entry>
  <gAcl:withKey key='[ACL KEY]'><gAcl:role value='reader' /></gAcl:withKey>
  <gAcl:scope type='default' />
</entry>

.NET

The following code shares the first document in the feed with all Google Docs users who have the specified key, and gives those users read permission.

using System;
using Google.GData.AccessControl;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate a DocumentsListQuery object to retrieve documents.
      DocumentsListQuery query = new DocumentsListQuery();

      // Make a request to the API and get all documents.
      DocumentsFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        // TODO: There were no documents, act accordingly.
      }

      // TODO: Choose a resource based on your app's needs.
      DocumentEntry entry = (DocumentEntry)feed.Entries[0];

      // Instantiate a AclEntryWithKey object to share with keys.
      AclEntryWithKey acl = new AclEntryWithKey();

      // Set the ACL scope.
      acl.Scope = new AclScope("", "default");

      // Instantiate a AclWithKey object to specify a key.
      AclWithKey withKey = new AclWithKey("[ACL KEY]");

      // Set the ACL role.
      withKey.Role = new AclRole("reader");

      // Set the WithKey property of the AclEntryWithKey element.
      acl.WithKey = withKey;

      // Insert the new role into the ACL feed.
      service.Insert(new Uri(entry.AccessControlList), acl);
    }
  }
}

Protocol

POST https://docs.google.com/feeds/default/private/archive
Authorization: <your authorization header here>
Content-Length: 457
Content-Type: application/atom+xml

<entry xmlns="http://www.w3.org/2005/Atom" xmlns:docs="http://schemas.google.com/docs/2007">
  <docs:archiveResourceId>document:0A1234567890</docs:archiveResourceId>
  <docs:archiveResourceId>spreadsheet:0A1234567890</docs:archiveResourceId>
  <docs:archiveResourceId>presentation:0A1234567890</docs:archiveResourceId>
  <docs:archiveResourceId>pdf:0A12sdf</docs:archiveResourceId>
  <docs:archiveResourceId>folder:0A1234567890</docs:archiveResourceId>
  <docs:archiveConversion source='application/vnd.google-apps.document' target='application/msword'/>
  <docs:archiveConversion source='application/vnd.google-apps.spreadsheet' target='text/csv'/>
  <docs:archiveConversion source='application/pdf' target='application/pdf'/>
  <docs:archiveNotify>user@gmail.com</docs:archiveNotify>
</entry>

The response contains information about the archive.

<?xml version='1.0' encoding='utf-8'?>
<entry xmlns='http://www.w3.org/2005/Atom'
xmlns:docs='http://schemas.google.com/docs/2007'
xmlns:gd='http://schemas.google.com/g/2005'>
  <id>
  https://docs.google.com/feeds/archive/-228SJEnnmwemsiDLLxmGeGygWrvW1tMZHHg6ARCy3Uj3SMH1GHlJ2scb8BcHSDDDUosQAocwBQOAKHOq3-0gmKA</id>
  <published>2010-11-18T18:34:06.981Z</published>
  <updated>2010-11-18T18:34:07.763Z</updated>
  <app:edited xmlns:app='http://www.w3.org/2007/app'>
  2010-11-18T18:34:07.763Z</app:edited>
  <category scheme='http://schemas.google.com/g/2005#kind'
  term='http://schemas.google.com/docs/2007#archive'
  label='archive' />
  <title>Document Archive - someuser@somedomain.com</title>
  <link rel='self' type='application/atom+xml'
  href='https://docs.google.com/feeds/default/private/archive/-228SJEnnmwemsiDLLxmGeGygWrvW1tMZHHg6ARCy3Uj3SMH1GHlJ2scb8BcHSDDDUosQAocwBQOAKHOq3-0gmKA' />
  <link rel='edit' type='application/atom+xml'
  href='https://docs.google.com/feeds/default/private/archive/-228SJEnnmwemsiDLLxmGeGygWrvW1tMZHHg6ARCy3Uj3SMH1GHlJ2scb8BcHSDDDUosQAocwBQOAKHOq3-0gmKA' />
  <author>
    <name>someuser</name>
    <email>someuser@somedomain.com</email>
  </author>
  <docs:archiveNotify>someuser@somedomain.com</docs:archiveNotify>
  <docs:archiveStatus>flattening</docs:archiveStatus>
  <docs:archiveResourceId>
  0Adj-hQNOVsTFSNDEkdk2221OTJfMWpxOGI5OWZu</docs:archiveResourceId>
  <docs:archiveResourceId>
  0Adj-hQNOVsTFZGZodGs2O72NFMllMQDN3a2Rq</docs:archiveResourceId>
  <docs:archiveConversion source='application/vnd.google-apps.document'
  target='text/plain' />
</entry>

.NET

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate an ArchiveEntry object to initiate an archive request.
      ArchiveEntry entry = new ArchiveEntry();

      // Add the IDs of the resources to be included in the archive.
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("document:0A1234567890"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("spreadsheet:0A1234567890"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("presentation:0A1234567890"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("pdf:0A12sdf"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("folder:0A1234567890"));

      // Specify the conversion formats for each entry.
      entry.ArchiveConversions.Add(new ArchiveConversion("application/vnd.google-apps.document", "application/msword"));
      entry.ArchiveConversions.Add(new ArchiveConversion("application/vnd.google-apps.spreadsheet", "text/csv"));
      entry.ArchiveConversions.Add(new ArchiveConversion("application/pdf", "application/pdf"));

      // Set the email address of the user to be notified.
      entry.ArchiveNotify = "user@gmail.com";

      // Send the archive request to the API.
      service.Insert(DocumentsListQuery.archiveUri, entry);
    }
  }
}

Protocol

When the archive operation is not complete:

GET https://docs.google.com/feeds/default/private/archive/<archive-id>
Authorization: <your authorization header here>

The response is:

200 OK

<?xml version='1.0' encoding='utf-8'?>
<entry xmlns='http://www.w3.org/2005/Atom'
xmlns:docs='http://schemas.google.com/docs/2007'
xmlns:gd='http://schemas.google.com/g/2005'>
  <id>
  https://docs.google.com/feeds/archive/-228SJEnnmwemsiDLLxmGeGygWrvW1tMZHHg6ARCy3Uj3SMH1GHlJ2scb8BcHSDDDUosQAocwBQOAKHOq3-0gmKA</id>
  <published>2010-11-18T18:34:06.981Z</published>
  <updated>2010-11-18T19:13:31.266Z</updated>
  <app:edited xmlns:app='http://www.w3.org/2007/app'>
  2010-11-18T19:13:31.266Z</app:edited>
  <category scheme='http://schemas.google.com/g/2005#kind'
  term='http://schemas.google.com/docs/2007#archive'
  label='archive' />
  <title>Document Archive - someuser@somedomain.com</title>
  <link rel='self' type='application/atom+xml'
  href='https://docs.google.com/feeds/default/private/archive/-228SJEnnmwemsiDLLxmGeGygWrvW1tMZHHg6ARCy3Uj3SMH1GHlJ2scb8BcHSDDDUosQAocwBQOAKHOq3-0gmKA' />
  <link rel='edit' type='application/atom+xml'
  href='https://docs.google.com/feeds/default/private/archive/-228SJEnnmwemsiDLLxmGeGygWrvW1tMZHHg6ARCy3Uj3SMH1GHlJ2scb8BcHSDDDUosQAocwBQOAKHOq3-0gmKA' />
  <author>
    <name>someuser</name>
    <email>someuser@somedomain.com</email>
  </author>
  <docs:archiveNotify>someuser@somedomain.com</docs:archiveNotify>
  <docs:archiveStatus>archiving</docs:archiveStatus>
  <docs:archiveResourceId>0Adj-hQNOVsTFSNDEkdk2221OTJfMWpxOGI5OWZu</docs:archiveResourceId>
  <docs:archiveResourceId>0Adj-hQNOVsTFZGZodGs2O72NFMllMQDN3a2Rq</docs:archiveResourceId>
  <docs:archiveConversion source='application/vnd.google-apps.document' target='text/plain' />
</entry>

When the archive operation is complete:

GET https://docs.google.com/feeds/default/private/archive/<archive-id>
Authorization: <your authorization header here>
The response will be:
<?xml version='1.0' encoding='utf-8'?>
<entry xmlns='http://www.w3.org/2005/Atom'
xmlns:docs='http://schemas.google.com/docs/2007'
xmlns:gd='http://schemas.google.com/g/2005'>
  <id>
  https://docs.google.com/feeds/archive/-228SJEnnmwemsiDLLxmGeGygWrvW1tMZHHg6ARCy3Uj3SMH1GHlJ2scb8BcHSDDDUosQAocwBQOAKHOq3-0gmKA</id>
  <published>2010-11-18T18:34:06.981Z</published>
  <updated>2010-11-18T19:13:31.266Z</updated>
  <app:edited xmlns:app='http://www.w3.org/2007/app'>
  2010-11-18T19:13:31.266Z</app:edited>
  <category scheme='http://schemas.google.com/g/2005#kind'
  term='http://schemas.google.com/docs/2007#archive'
  label='archive' />
  <title>Document Archive - someuser@somedomain.com</title>
  <content type='application/zip'      src='https://doc-00-90-docs.googleusercontent.com/docs/secure/he0nmogeutv9f47fuhdm5052r4methcr/82t504tsh5roodr6f8qr4lpdlng1hkjk/1290103200000/15266010465028272046/15266010465028272046/-228SJEnnmwemsiDLLxmGeGygWrvW1tMZHHg6ARCy3Uj3SMH1GHlJ2scb8BcHSDDDUosQAocwBQOAKHOq3-0gmKA?a=docs-archive-2010-11-18.zip&ai=-228SJEnnmwemsiDLLxmGeGygWrvW1tMZHHg6ARCy3Uj3SMH1GHlJ2scb8BcHSDDDUosQAocwBQOAKHOq3-0gmKA&ap=grOCTZLfQ5X0EArImf6Qfdg4ZlilxR6JNmObNJCbc6Q&h=18423295174435396830&gd=true' />
  <link rel='self' type='application/atom+xml'
  href='https://docs.google.com/feeds/default/private/archive/-228SJEnnmwemsiDLLxmGeGygWrvW1tMZHHg6ARCy3Uj3SMH1GHlJ2scb8BcHSDDDUosQAocwBQOAKHOq3-0gmKA' />
  <link rel='edit' type='application/atom+xml'
  href='https://docs.google.com/feeds/default/private/archive/-228SJEnnmwemsiDLLxmGeGygWrvW1tMZHHg6ARCy3Uj3SMH1GHlJ2scb8BcHSDDDUosQAocwBQOAKHOq3-0gmKA' />
  <author>
    <name>someuser</name>
    <email>someuser@somedomain.com</email>
  </author>
  <docs:archiveNotify>someuser@somedomain.com</docs:archiveNotify>
  <docs:archiveStatus>finished</docs:archiveStatus>
  <gd:quotaBytesUsed>308</gd:quotaBytesUsed>
  <docs:archiveNotifyStatus>sent</docs:archiveNotifyStatus>
  <docs:archiveComplete>2010-11-18T18:34:09.679Z</docs:archiveComplete>
  <docs:archiveTotal>2</docs:archiveTotal>
  <docs:archiveTotalComplete>2</docs:archiveTotalComplete>
  <docs:archiveTotalFailure>0</docs:archiveTotalFailure>
  <docs:archiveResourceId>0Adj-hQNOVsTFSNDEkdk2221OTJfMWpxOGI5OWZu</docs:archiveResourceId>
  <docs:archiveResourceId>0Adj-hQNOVsTFZGZodGs2O72NFMllMQDN3a2Rq</docs:archiveResourceId>
  <docs:archiveConversion source='application/vnd.google-apps.document' target='text/plain' />
</entry>

.NET

The following code sends an archive request, then fetches its status and prints the value of the archiveStatus property.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate an ArchiveEntry object to initiate an archive request.
      ArchiveEntry entry = new ArchiveEntry();

      // Add the IDs of the resources to be included in the archive.
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("document:0A1234567890"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("spreadsheet:0A1234567890"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("presentation:0A1234567890"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("pdf:0A12sdf"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("folder:0A1234567890"));

      // Specify the conversion formats for each entry.
      entry.ArchiveConversions.Add(new ArchiveConversion("application/vnd.google-apps.document", "application/msword"));
      entry.ArchiveConversions.Add(new ArchiveConversion("application/vnd.google-apps.spreadsheet", "text/csv"));
      entry.ArchiveConversions.Add(new ArchiveConversion("application/pdf", "application/pdf"));

      // Set the email address of the user to be notified.
      entry.ArchiveNotify = "user@gmail.com";

      // Send the archive request to the API.
      entry = service.Insert(DocumentsListQuery.archiveUri, entry);

      // Instantiate an ArchiveQuery object to retrieve archives.
      ArchiveQuery query = new ArchiveQuery(archiveId);

      // Make a request to the API and get the archive feed.
      ArchiveFeed feed = service.Query(query);

      if (feed.Entries.Count == 0)
      {
        throw new Exception("The archive feed should always contain an entry");
      }

      // The archive feed contains a single entry.
      entry = (ArchiveEntry)feed.Entries[0];

      // Print the status of the archive operation.
      Console.WriteLine(entry.ArchiveStatus);
    }
  }
}

Protocol

PUT https://docs.google.com/feeds/default/private/archive/ Authorization:

<entry xmlns="http://www.w3.org/2005/Atom" xmlns:docs="http://schemas.google.com/docs/2007"
       xmlns:gd="http://schemas.google.com/g/2005">
  ...
  <docs:archiveNotify>different_user@example.com</docs:archiveNotify>
</entry>

.NET

The following code sends an archive request, then updates its notification email address.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate an ArchiveEntry object to initiate an archive request.
      ArchiveEntry entry = new ArchiveEntry();

      // Add the IDs of the resources to be included in the archive.
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("document:0A1234567890"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("spreadsheet:0A1234567890"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("presentation:0A1234567890"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("pdf:0A12sdf"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("folder:0A1234567890"));

      // Specify the conversion formats for each entry.
      entry.ArchiveConversions.Add(new ArchiveConversion("application/vnd.google-apps.document", "application/msword"));
      entry.ArchiveConversions.Add(new ArchiveConversion("application/vnd.google-apps.spreadsheet", "text/csv"));
      entry.ArchiveConversions.Add(new ArchiveConversion("application/pdf", "application/pdf"));

      // Set the email address of the user to be notified.
      entry.ArchiveNotify = "user@gmail.com";

      // Send the archive request to the API.
      entry = service.Insert(DocumentsListQuery.archiveUri, entry);

      // Set the new notification email address.
      entry.ArchiveNotify = "different_user@example.com";

      // Make a request to the API and update the archive.
      entry.Update();
  }
}

Protocol

DELETE https://docs.google.com/feeds/default/private/archive/

.NET

The following code sends an archive request, then aborts the operation.

using System;
using Google.GData.Client;
using Google.GData.Documents;

namespace MyDocumentsListIntegration
{
  class Program
  {
    static void Main(string[] args)
    {
      DocumentsService service = new DocumentsService("MyDocumentsListIntegration-v1");

      // TODO: Authorize the service object for a specific user (see Authorizing requests)

      // Instantiate an ArchiveEntry object to initiate an archive request.
      ArchiveEntry entry = new ArchiveEntry();

      // Add the IDs of the resources to be included in the archive.
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("document:0A1234567890"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("spreadsheet:0A1234567890"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("presentation:0A1234567890"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("pdf:0A12sdf"));
      entry.ArchiveResourceIds.Add(new ArchiveResourceId("folder:0A1234567890"));

      // Specify the conversion formats for each entry.
      entry.ArchiveConversions.Add(new ArchiveConversion("application/vnd.google-apps.document", "application/msword"));
      entry.ArchiveConversions.Add(new ArchiveConversion("application/vnd.google-apps.spreadsheet", "text/csv"));
      entry.ArchiveConversions.Add(new ArchiveConversion("application/pdf", "application/pdf"));

      // Set the email address of the user to be notified.
      entry.ArchiveNotify = "user@gmail.com";

      // Send the archive request to the API.
      entry = service.Insert(DocumentsListQuery.archiveUri, entry);

      // Make a request to the API and abort the operation.
      entry.Delete();
  }
}