diff --git a/autotests/drive/aboutfetchjobtest.cpp b/autotests/drive/aboutfetchjobtest.cpp
--- a/autotests/drive/aboutfetchjobtest.cpp
+++ b/autotests/drive/aboutfetchjobtest.cpp
@@ -17,7 +17,7 @@
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library.  If not, see <https://www.gnu.org/licenses/>.
  */
-
+#include <cstring>
 #include <QObject>
 #include <QTest>
 
@@ -32,7 +32,12 @@
 
 using namespace KGAPI2;
 
+namespace {
+    static const char *LimitedFieldTag = "limited fields";
+}
+
 Q_DECLARE_METATYPE(QList<FakeNetworkAccessManager::Scenario>)
+Q_DECLARE_METATYPE(KGAPI2::Drive::AboutPtr)
 
 class AboutFetchJobTest : public QObject
 {
@@ -43,17 +48,40 @@
         NetworkAccessManagerFactory::setFactory(new FakeNetworkAccessManagerFactory);
     }
 
+    void testFetch_data()
+    {
+        QTest::addColumn<QList<FakeNetworkAccessManager::Scenario>>("scenarios");
+        QTest::addColumn<KGAPI2::Drive::AboutPtr>("about");
+
+        QTest::newRow("")
+            << QList<FakeNetworkAccessManager::Scenario>{
+                    scenarioFromFile(QFINDTESTDATA("data/about_fetch_request.txt"),
+                                     QFINDTESTDATA("data/about_fetch_response.txt"))
+                }
+            << aboutFromFile(QFINDTESTDATA("data/about.json"));
+
+        QTest::newRow(LimitedFieldTag)
+            << QList<FakeNetworkAccessManager::Scenario>{
+                    scenarioFromFile(QFINDTESTDATA("data/about_fetch_limited_fields_request.txt"),
+                                     QFINDTESTDATA("data/about_fetch_limited_fields_response.txt"))
+                }
+            << aboutFromFile(QFINDTESTDATA("data/about_limited_fields.json"));
+    }
+
     void testFetch()
     {
-        FakeNetworkAccessManagerFactory::get()->setScenarios({
-            scenarioFromFile(QFINDTESTDATA("data/about_fetch_request.txt"),
-                             QFINDTESTDATA("data/about_fetch_response.txt"))
+        QFETCH(QList<FakeNetworkAccessManager::Scenario>, scenarios);
+        QFETCH(KGAPI2::Drive::AboutPtr, about);
 
-        });
-        const auto about = aboutFromFile(QFINDTESTDATA("data/about.json"));
+        FakeNetworkAccessManagerFactory::get()->setScenarios(scenarios);
 
         auto account = AccountPtr::create(QStringLiteral("MockAccount"), QStringLiteral("MockToken"));
         auto job = new Drive::AboutFetchJob(account, nullptr);
+
+        if (strcmp(LimitedFieldTag, QTest::currentDataTag()) == 0) {
+            job->setFields({ Drive::About::Fields::Kind, Drive::About::Fields::PermissionId});
+        }
+
         QVERIFY(execJob(job));
         const auto items = job->items();
         QCOMPARE(items.count(), 1);
diff --git a/autotests/drive/data/about_fetch_limited_fields_request.txt b/autotests/drive/data/about_fetch_limited_fields_request.txt
new file mode 100644
--- /dev/null
+++ b/autotests/drive/data/about_fetch_limited_fields_request.txt
@@ -0,0 +1 @@
+GET https://www.googleapis.com/drive/v2/about?includeSubscribed=true&fields=kind,permissionId&prettyPrint=false
diff --git a/autotests/drive/data/about_fetch_limited_fields_response.txt b/autotests/drive/data/about_fetch_limited_fields_response.txt
new file mode 100644
--- /dev/null
+++ b/autotests/drive/data/about_fetch_limited_fields_response.txt
@@ -0,0 +1,7 @@
+HTTP/1.1 200 OK
+content-type: application/json; charset=UTF-8
+
+{
+  "kind": "drive#about",
+  "permissionId": "07857126568572968161"
+}
diff --git a/autotests/drive/data/about_limited_fields.json b/autotests/drive/data/about_limited_fields.json
new file mode 100644
--- /dev/null
+++ b/autotests/drive/data/about_limited_fields.json
@@ -0,0 +1,4 @@
+{
+  "kind": "drive#about",
+  "permissionId": "07857126568572968161"
+}
diff --git a/examples/teamdrive/mainwindow.cpp b/examples/teamdrive/mainwindow.cpp
--- a/examples/teamdrive/mainwindow.cpp
+++ b/examples/teamdrive/mainwindow.cpp
@@ -263,10 +263,10 @@
     query.addQuery(KGAPI2::Drive::FileSearchQuery::Parents, KGAPI2::Drive::FileSearchQuery::In, id);
 
     KGAPI2::Drive::FileFetchJob *fileFetchJob = new KGAPI2::Drive::FileFetchJob(query, m_account, nullptr);
-    fileFetchJob->setFields((KGAPI2::Drive::FileFetchJob::BasicFields & ~KGAPI2::Drive::FileFetchJob::Permissions)
-                            | KGAPI2::Drive::FileFetchJob::Labels
-                            | KGAPI2::Drive::FileFetchJob::ExportLinks
-                            | KGAPI2::Drive::FileFetchJob::LastViewedByMeDate);
+    fileFetchJob->setFields({
+        KGAPI2::Drive::File::Fields::Id,
+        KGAPI2::Drive::File::Fields::Title,
+    });
     connect(fileFetchJob, &KGAPI2::Job::finished,
             this, &MainWindow::slotTeamdriveFetchJobFinished);
 }
@@ -309,10 +309,10 @@
     const QString id = m_ui->teamdrivePreviewList->selectedItems().at(0)->data(Qt::UserRole).toString();
 
     KGAPI2::Drive::FileFetchJob *fileFetchJob = new KGAPI2::Drive::FileFetchJob(id, m_account, nullptr);
-    fileFetchJob->setFields((KGAPI2::Drive::FileFetchJob::BasicFields & ~KGAPI2::Drive::FileFetchJob::Permissions)
-                            | KGAPI2::Drive::FileFetchJob::Labels
-                            | KGAPI2::Drive::FileFetchJob::ExportLinks
-                            | KGAPI2::Drive::FileFetchJob::LastViewedByMeDate);
+    fileFetchJob->setFields({
+        KGAPI2::Drive::File::Fields::Title,
+        KGAPI2::Drive::File::Fields::FileSize,
+    });
     connect(fileFetchJob, &KGAPI2::Job::finished,
             this, &MainWindow::slotTeamdriveItemFetchJobFinished);
 }
diff --git a/src/core/job.h b/src/core/job.h
--- a/src/core/job.h
+++ b/src/core/job.h
@@ -100,6 +100,7 @@
 
     struct StandardParams {
         static const QString PrettyPrint;
+        static const QString Fields;
     };
 
     /**
@@ -202,6 +203,22 @@
      */
     bool prettyPrint() const;
 
+    /**
+     * @brief Set subset of fields to include in the response.
+     *
+     * Use for better performance.
+     *
+     * @param fields List of fields
+     */
+    void setFields(const QStringList &fields);
+
+    /**
+     * @brief Returns fields selector.
+     *
+     * @return List of fields
+     */
+    QStringList fields() const;
+
     /**
      * @brief Restarts this job
      *
diff --git a/src/core/job.cpp b/src/core/job.cpp
--- a/src/core/job.cpp
+++ b/src/core/job.cpp
@@ -330,6 +330,9 @@
 
     QUrl url = authorizedRequest.url();
     QUrlQuery standardParamQuery(url);
+    if (!fields.isEmpty()) {
+        standardParamQuery.addQueryItem(Job::StandardParams::Fields, fields.join(QStringLiteral(",")));
+    }
 
     if (!standardParamQuery.hasQueryItem(Job::StandardParams::PrettyPrint)) {
         standardParamQuery.addQueryItem(Job::StandardParams::PrettyPrint, prettyPrint ? QStringLiteral("true") : QStringLiteral("false"));
@@ -351,6 +354,7 @@
 /************************* PUBLIC **********************/
 
 const QString Job::StandardParams::PrettyPrint = QStringLiteral("prettyPrint");
+const QString Job::StandardParams::Fields = QStringLiteral("fields");
 
 Job::Job(QObject* parent):
     QObject(parent),
@@ -453,6 +457,17 @@
 
     d->prettyPrint = prettyPrint;
 }
+
+QStringList Job::fields() const
+{
+    return d->fields;
+}
+
+void Job::setFields(const QStringList &fields)
+{
+    d->fields = fields;
+}
+
 void Job::restart()
 {
     if (d->isRunning) {
diff --git a/src/core/job_p.h b/src/core/job_p.h
--- a/src/core/job_p.h
+++ b/src/core/job_p.h
@@ -82,6 +82,7 @@
     QTimer *dispatchTimer;
     int maxTimeout;
     bool prettyPrint;
+    QStringList fields;
 
     Request currentRequest;
 
diff --git a/src/drive/about.h b/src/drive/about.h
--- a/src/drive/about.h
+++ b/src/drive/about.h
@@ -221,8 +221,56 @@
     typedef QSharedPointer<MaxUploadSize> MaxUploadSizePtr;
     typedef QList<MaxUploadSizePtr> MaxUploadSizesList;
 
-    explicit About(const About &other);
-    virtual ~About();
+    struct Fields {
+        static const QString AdditionalRoleInfo;
+        static const QString AdditionalRoles;
+        static const QString BackgroundImageLink;
+        static const QString BytesUsed;
+        static const QString CanCreateTeamDrives;
+        static const QString ColorRgb;
+        static const QString DisplayName;
+        static const QString DomainSharingPolicy;
+        static const QString EmailAddress;
+        static const QString Etag;
+        static const QString ExportFormats;
+        static const QString FeatureName;
+        static const QString FeatureRate;
+        static const QString Features;
+        static const QString FolderColorPalette;
+        static const QString Id;
+        static const QString ImportFormats;
+        static const QString IsAuthenticatedUser;
+        static const QString IsCurrentAppInstalled;
+        static const QString Kind;
+        static const QString LanguageCode;
+        static const QString LargestChangeId;
+        static const QString MaxUploadSizes;
+        static const QString Name;
+        static const QString PermissionId;
+        static const QString Picture;
+        static const QString PrimaryRole;
+        static const QString QuotaBytesByService;
+        static const QString QuotaBytesTotal;
+        static const QString QuotaBytesUsed;
+        static const QString QuotaBytesUsedAggregate;
+        static const QString QuotaBytesUsedInTrash;
+        static const QString QuotaType;
+        static const QString RemainingChangeIds;
+        static const QString RoleSets;
+        static const QString RootFolderId;
+        static const QString SelfLink;
+        static const QString ServiceName;
+        static const QString Size;
+        static const QString Source;
+        static const QString Targets;
+        static const QString TeamDriveThemes;
+        static const QString Type;
+        static const QString Url;
+        static const QString User;
+    };
+
+    About(const About &other);
+    ~About() override;
 
     bool operator==(const About &other) const;
     bool operator!=(const About &other) const { return !operator==(other); }
@@ -340,10 +388,10 @@
     static AboutPtr fromJSON(const QByteArray &jsonData);
 
   private:
-    explicit About();
+    About();
 
     class Private;
-    Private *const d;
+    QScopedPointer<Private> const d;
     friend class Private;
 };
 
diff --git a/src/drive/about.cpp b/src/drive/about.cpp
--- a/src/drive/about.cpp
+++ b/src/drive/about.cpp
@@ -361,6 +361,52 @@
 {
 }
 
+const QString About::Fields::AdditionalRoleInfo = QStringLiteral("additionalRoleInfo");
+const QString About::Fields::AdditionalRoles = QStringLiteral("additionalRoles");
+const QString About::Fields::BackgroundImageLink = QStringLiteral("backgroundImageLink");
+const QString About::Fields::BytesUsed = QStringLiteral("bytesUsed");
+const QString About::Fields::CanCreateTeamDrives = QStringLiteral("canCreateTeamDrives");
+const QString About::Fields::ColorRgb = QStringLiteral("colorRgb");
+const QString About::Fields::DisplayName = QStringLiteral("displayName");
+const QString About::Fields::DomainSharingPolicy = QStringLiteral("domainSharingPolicy");
+const QString About::Fields::EmailAddress = QStringLiteral("emailAddress");
+const QString About::Fields::Etag = QStringLiteral("etag");
+const QString About::Fields::ExportFormats = QStringLiteral("exportFormats");
+const QString About::Fields::FeatureName = QStringLiteral("featureName");
+const QString About::Fields::FeatureRate = QStringLiteral("featureRate");
+const QString About::Fields::Features = QStringLiteral("features");
+const QString About::Fields::FolderColorPalette = QStringLiteral("folderColorPalette");
+const QString About::Fields::Id = QStringLiteral("id");
+const QString About::Fields::ImportFormats = QStringLiteral("importFormats");
+const QString About::Fields::IsAuthenticatedUser = QStringLiteral("isAuthenticatedUser");
+const QString About::Fields::IsCurrentAppInstalled = QStringLiteral("isCurrentAppInstalled");
+const QString About::Fields::Kind = QStringLiteral("kind");
+const QString About::Fields::LanguageCode = QStringLiteral("languageCode");
+const QString About::Fields::LargestChangeId = QStringLiteral("largestChangeId");
+const QString About::Fields::MaxUploadSizes = QStringLiteral("maxUploadSizes");
+const QString About::Fields::Name = QStringLiteral("name");
+const QString About::Fields::PermissionId = QStringLiteral("permissionId");
+const QString About::Fields::Picture = QStringLiteral("picture");
+const QString About::Fields::PrimaryRole = QStringLiteral("primaryRole");
+const QString About::Fields::QuotaBytesByService = QStringLiteral("quotaBytesByService");
+const QString About::Fields::QuotaBytesTotal = QStringLiteral("quotaBytesTotal");
+const QString About::Fields::QuotaBytesUsedAggregate = QStringLiteral("quotaBytesUsedAggregate");
+const QString About::Fields::QuotaBytesUsedInTrash = QStringLiteral("quotaBytesUsedInTrash");
+const QString About::Fields::QuotaBytesUsed = QStringLiteral("quotaBytesUsed");
+const QString About::Fields::QuotaType = QStringLiteral("quotaType");
+const QString About::Fields::RemainingChangeIds = QStringLiteral("remainingChangeIds");
+const QString About::Fields::RoleSets = QStringLiteral("roleSets");
+const QString About::Fields::RootFolderId = QStringLiteral("rootFolderId");
+const QString About::Fields::SelfLink = QStringLiteral("selfLink");
+const QString About::Fields::ServiceName = QStringLiteral("serviceName");
+const QString About::Fields::Size = QStringLiteral("size");
+const QString About::Fields::Source = QStringLiteral("source");
+const QString About::Fields::Targets = QStringLiteral("targets");
+const QString About::Fields::TeamDriveThemes = QStringLiteral("teamDriveThemes");
+const QString About::Fields::Type = QStringLiteral("type");
+const QString About::Fields::Url = QStringLiteral("url");
+const QString About::Fields::User = QStringLiteral("user");
+
 About::About():
     KGAPI2::Object(),
     d(new Private)
@@ -373,10 +419,7 @@
 {
 }
 
-About::~About()
-{
-    delete d;
-}
+About::~About() = default;
 
 bool About::operator==(const About &other) const
 {
diff --git a/src/drive/file.h b/src/drive/file.h
--- a/src/drive/file.h
+++ b/src/drive/file.h
@@ -602,6 +602,59 @@
 
     bool isFolder() const;
 
+    struct Fields {
+        static const QString SelfLink;
+        static const QString Etag;
+        static const QString Kind;
+        static const QString NextLink;
+        static const QString NextPageToken;
+        static const QString Id;
+        static const QString Title;
+        static const QString MimeType;
+        static const QString Description;
+        static const QString Labels;
+        static const QString CreatedDate;
+        static const QString ModifiedDate;
+        static const QString ModifiedByMeDate;
+        static const QString DownloadUrl;
+        static const QString IndexableText;
+        static const QString UserPermission;
+        static const QString FileExtension;
+        static const QString Md5Checksum;
+        static const QString FileSize;
+        static const QString AlternateLink;
+        static const QString EmbedLink;
+        static const QString SharedWithMeDate;
+        static const QString Parents;
+        static const QString ExportLinks;
+        static const QString OriginalFilename;
+        static const QString OwnerNames;
+        static const QString LastModifiedByMeDate;
+        static const QString Editable;
+        static const QString WritersCanShare;
+        static const QString ThumbnailLink;
+        static const QString LastViewedByMeDate;
+        static const QString WebContentLink;
+        static const QString ExplicitlyTrashed;
+        static const QString ImageMediaMetadata;
+        static const QString Thumbnail;
+        static const QString WebViewLink;
+        static const QString IconLink;
+        static const QString Shared;
+        static const QString Owners;
+        static const QString LastModifyingUser;
+        static const QString AppDataContents;
+        static const QString OpenWithLinks;
+        static const QString DefaultOpenWithLink;
+        static const QString HeadRevisionId;
+        static const QString Copyable;
+        static const QString Properties;
+        static const QString MarkedViewedByMeDate;
+        static const QString Version;
+        static const QString SharingUser;
+        static const QString Permissions;
+    };
+
     static FilePtr fromJSON(const QByteArray &jsonData);
     static FilesList fromJSONFeed(const  QByteArray &jsonData, FeedData &feedData);
     static QByteArray toJSON(const FilePtr &file, SerializationOptions options = NoOptions);
diff --git a/src/drive/file.cpp b/src/drive/file.cpp
--- a/src/drive/file.cpp
+++ b/src/drive/file.cpp
@@ -525,7 +525,7 @@
 {
     const QByteArray ba = QByteArray::fromBase64(map[QStringLiteral("image")].toByteArray());
     d->image = QImage::fromData(ba);
-    d->mimeType = map[QStringLiteral("mimeType")].toString();
+    d->mimeType = map[Fields::MimeType].toString();
 }
 
 File::Thumbnail::Thumbnail(const File::Thumbnail &other):
@@ -655,21 +655,21 @@
 
 FilePtr File::Private::fromJSON(const QVariantMap &map)
 {
-    if (!map.contains(QStringLiteral("kind")) ||
-        map[QStringLiteral("kind")].toString() != QLatin1String("drive#file"))
+    if (!map.contains(File::Fields::Kind) ||
+        map[File::Fields::Kind].toString() != QLatin1String("drive#file"))
     {
         return FilePtr();
     }
 
     FilePtr file(new File());
-    file->setEtag(map[QStringLiteral("etag")].toString());
-    file->d->id = map[QStringLiteral("id")].toString();
-    file->d->selfLink = map[QStringLiteral("selfLink")].toUrl();
-    file->d->title = map[QStringLiteral("title")].toString();
-    file->d->mimeType = map[QStringLiteral("mimeType")].toString();
-    file->d->description = map[QStringLiteral("description")].toString();
-
-    const QVariantMap labelsData =  map[QStringLiteral("labels")].toMap();
+    file->setEtag(map[Fields::Etag].toString());
+    file->d->id = map[Fields::Id].toString();
+    file->d->selfLink = map[Fields::SelfLink].toUrl();
+    file->d->title = map[Fields::Title].toString();
+    file->d->mimeType = map[Fields::MimeType].toString();
+    file->d->description = map[Fields::Description].toString();
+
+    const QVariantMap labelsData =  map[Fields::Labels].toMap();
     File::LabelsPtr labels(new File::Labels());
     labels->d->starred = labelsData[QStringLiteral("starred")].toBool();
     labels->d->hidden = labelsData[QStringLiteral("hidden")].toBool();
@@ -679,33 +679,33 @@
     file->d->labels = labels;
 
     // FIXME FIXME FIXME Verify the date format
-    file->d->createdDate = QDateTime::fromString(map[QStringLiteral("createdDate")].toString(), Qt::ISODate);
-    file->d->modifiedDate = QDateTime::fromString(map[QStringLiteral("modifiedDate")].toString(), Qt::ISODate);
-    file->d->modifiedByMeDate = QDateTime::fromString(map[QStringLiteral("modifiedByMeDate")].toString(), Qt::ISODate);
-    file->d->downloadUrl = map[QStringLiteral("downloadUrl")].toUrl();
+    file->d->createdDate = QDateTime::fromString(map[Fields::CreatedDate].toString(), Qt::ISODate);
+    file->d->modifiedDate = QDateTime::fromString(map[Fields::ModifiedDate].toString(), Qt::ISODate);
+    file->d->modifiedByMeDate = QDateTime::fromString(map[Fields::ModifiedByMeDate].toString(), Qt::ISODate);
+    file->d->downloadUrl = map[Fields::DownloadUrl].toUrl();
 
-    const QVariantMap indexableTextData = map[QStringLiteral("indexableText")].toMap();
+    const QVariantMap indexableTextData = map[Fields::IndexableText].toMap();
     File::IndexableTextPtr indexableText(new File::IndexableText());
     indexableText->d->text = indexableTextData[QStringLiteral("text")].toString();
     file->d->indexableText = indexableText;
 
-    const QVariantMap userPermissionData = map[QStringLiteral("userPermission")].toMap();
+    const QVariantMap userPermissionData = map[Fields::UserPermission].toMap();
     file->d->userPermission = Permission::Private::fromJSON(userPermissionData);
 
-    file->d->fileExtension = map[QStringLiteral("fileExtension")].toString();
-    file->d->md5Checksum = map[QStringLiteral("md5Checksum")].toString();
-    file->d->fileSize = map[QStringLiteral("fileSize")].toLongLong();
-    file->d->alternateLink = map[QStringLiteral("alternateLink")].toUrl();
-    file->d->embedLink = map[QStringLiteral("embedLink")].toUrl();
-    file->d->sharedWithMeDate = QDateTime::fromString(map[QStringLiteral("sharedWithMeDate")].toString(), Qt::ISODate);
+    file->d->fileExtension = map[Fields::FileExtension].toString();
+    file->d->md5Checksum = map[Fields::Md5Checksum].toString();
+    file->d->fileSize = map[Fields::FileSize].toLongLong();
+    file->d->alternateLink = map[Fields::AlternateLink].toUrl();
+    file->d->embedLink = map[Fields::EmbedLink].toUrl();
+    file->d->sharedWithMeDate = QDateTime::fromString(map[Fields::SharedWithMeDate].toString(), Qt::ISODate);
 
-    const QVariantList parents = map[QStringLiteral("parents")].toList();
+    const QVariantList parents = map[Fields::Parents].toList();
     for (const QVariant &parent : parents)
     {
         file->d->parents << ParentReference::Private::fromJSON(parent.toMap());
     }
 
-    const QVariantMap exportLinksData = map[QStringLiteral("exportLinks")].toMap();
+    const QVariantMap exportLinksData = map[Fields::ExportLinks].toMap();
     QVariantMap::ConstIterator iter = exportLinksData.constBegin();
     for ( ; iter != exportLinksData.constEnd(); ++iter) {
         file->d->exportLinks.insert(iter.key(), iter.value().toUrl());
@@ -713,33 +713,33 @@
 
     file->d->originalFileName = map[QStringLiteral("originalFileName")].toString();
     file->d->quotaBytesUsed = map[QStringLiteral("quotaBytesUsed")].toLongLong();
-    file->d->ownerNames = map[QStringLiteral("ownerNames")].toStringList();
+    file->d->ownerNames = map[Fields::OwnerNames].toStringList();
     file->d->lastModifyingUserName = map[QStringLiteral("lastModifyingUserName")].toString();
-    file->d->editable = map[QStringLiteral("editable")].toBool();
-    file->d->writersCanShare = map[QStringLiteral("writersCanShare")].toBool();
-    file->d->thumbnailLink = map[QStringLiteral("thumbnailLink")].toUrl();
-    file->d->lastViewedByMeDate = QDateTime::fromString(map[QStringLiteral("lastViewedByMeDate")].toString(), Qt::ISODate);
-    file->d->webContentLink = map[QStringLiteral("webContentLink")].toUrl();
-    file->d->explicitlyTrashed = map[QStringLiteral("explicitlyTrashed")].toBool();
-
-    const QVariantMap imageMetaData = map[QStringLiteral("imageMediaMetadata")].toMap();
+    file->d->editable = map[Fields::Editable].toBool();
+    file->d->writersCanShare = map[Fields::WritersCanShare].toBool();
+    file->d->thumbnailLink = map[Fields::ThumbnailLink].toUrl();
+    file->d->lastViewedByMeDate = QDateTime::fromString(map[Fields::LastViewedByMeDate].toString(), Qt::ISODate);
+    file->d->webContentLink = map[Fields::WebContentLink].toUrl();
+    file->d->explicitlyTrashed = map[Fields::ExplicitlyTrashed].toBool();
+
+    const QVariantMap imageMetaData = map[Fields::ImageMediaMetadata].toMap();
     file->d->imageMediaMetadata =
         File::ImageMediaMetadataPtr(new File::ImageMediaMetadata(imageMetaData));
 
-    const QVariantMap thumbnailData = map[QStringLiteral("thumbnail")].toMap();
+    const QVariantMap thumbnailData = map[Fields::Thumbnail].toMap();
     File::ThumbnailPtr thumbnail(new File::Thumbnail(thumbnailData));
     file->d->thumbnail = thumbnail;
 
-    file->d->webViewLink = map[QStringLiteral("webViewLink")].toUrl();
-    file->d->iconLink = map[QStringLiteral("iconLink")].toUrl();
-    file->d->shared = map[QStringLiteral("shared")].toBool();
+    file->d->webViewLink = map[Fields::WebViewLink].toUrl();
+    file->d->iconLink = map[Fields::IconLink].toUrl();
+    file->d->shared = map[Fields::Shared].toBool();
 
-    const QVariantList ownersList = map[QStringLiteral("owners")].toList();
+    const QVariantList ownersList = map[Fields::Owners].toList();
     for (const QVariant &owner : ownersList) {
         file->d->owners << User::fromJSON(owner.toMap());
     }
 
-    const QVariantMap lastModifyingUser = map[QStringLiteral("lastModifyingUser")].toMap();
+    const QVariantMap lastModifyingUser = map[Fields::LastModifyingUser].toMap();
     file->d->lastModifyingUser = User::fromJSON(lastModifyingUser);
 
     return file;
@@ -991,6 +991,57 @@
     return (d->mimeType == File::folderMimeType());
 }
 
+const QString File::Fields::Kind = QStringLiteral("kind");
+const QString File::Fields::NextLink = QStringLiteral("nextLink");
+const QString File::Fields::NextPageToken = QStringLiteral("nextPageToken");
+const QString File::Fields::SelfLink = QStringLiteral("selfLink");
+const QString File::Fields::Etag = QStringLiteral("etag");
+const QString File::Fields::Id = QStringLiteral("id");
+const QString File::Fields::Title = QStringLiteral("title");
+const QString File::Fields::MimeType = QStringLiteral("mimeType");
+const QString File::Fields::Description = QStringLiteral("description");
+const QString File::Fields::Labels = QStringLiteral("labels");
+const QString File::Fields::CreatedDate = QStringLiteral("createdDate");
+const QString File::Fields::ModifiedDate = QStringLiteral("modifiedDate");
+const QString File::Fields::ModifiedByMeDate = QStringLiteral("modifiedByMeDate");
+const QString File::Fields::DownloadUrl = QStringLiteral("downloadUrl");
+const QString File::Fields::IndexableText = QStringLiteral("indexableText");
+const QString File::Fields::UserPermission = QStringLiteral("userPermission");
+const QString File::Fields::FileExtension = QStringLiteral("fileExtension");
+const QString File::Fields::Md5Checksum = QStringLiteral("md5Checksum");
+const QString File::Fields::FileSize = QStringLiteral("fileSize");
+const QString File::Fields::AlternateLink = QStringLiteral("alternateLink");
+const QString File::Fields::EmbedLink = QStringLiteral("embedLink");
+const QString File::Fields::SharedWithMeDate = QStringLiteral("sharedWithMeDate");
+const QString File::Fields::Parents = QStringLiteral("parents");
+const QString File::Fields::ExportLinks = QStringLiteral("exportLinks");
+const QString File::Fields::OriginalFilename = QStringLiteral("originalFilename");
+const QString File::Fields::OwnerNames = QStringLiteral("ownerNames");
+const QString File::Fields::LastModifiedByMeDate = QStringLiteral("lastModifiedByMeDate");
+const QString File::Fields::Editable = QStringLiteral("editable");
+const QString File::Fields::WritersCanShare = QStringLiteral("writersCanShare");
+const QString File::Fields::ThumbnailLink = QStringLiteral("thumbnailLink");
+const QString File::Fields::LastViewedByMeDate = QStringLiteral("lastViewedByMeDate");
+const QString File::Fields::WebContentLink = QStringLiteral("webContentLink");
+const QString File::Fields::ExplicitlyTrashed = QStringLiteral("explicitlyTrashed");
+const QString File::Fields::ImageMediaMetadata = QStringLiteral("imageMediaMetadata");
+const QString File::Fields::Thumbnail = QStringLiteral("thumbnail");
+const QString File::Fields::WebViewLink = QStringLiteral("webViewLink");
+const QString File::Fields::IconLink = QStringLiteral("iconLink");
+const QString File::Fields::Shared = QStringLiteral("shared");
+const QString File::Fields::Owners = QStringLiteral("owners");
+const QString File::Fields::LastModifyingUser = QStringLiteral("lastModifyingUser");
+const QString File::Fields::AppDataContents = QStringLiteral("appDataContents");
+const QString File::Fields::OpenWithLinks = QStringLiteral("openWithLinks");
+const QString File::Fields::DefaultOpenWithLink = QStringLiteral("defaultOpenWithLink");
+const QString File::Fields::HeadRevisionId = QStringLiteral("headRevisionId");
+const QString File::Fields::Copyable = QStringLiteral("copyable");
+const QString File::Fields::Properties = QStringLiteral("properties");
+const QString File::Fields::MarkedViewedByMeDate = QStringLiteral("markedViewedByMeDate");
+const QString File::Fields::Version = QStringLiteral("version");
+const QString File::Fields::SharingUser = QStringLiteral("sharingUser");
+const QString File::Fields::Permissions = QStringLiteral("permissions");
+
 FilePtr File::fromJSON(const QByteArray &jsonData)
 {
     QJsonDocument document = QJsonDocument::fromJson(jsonData);
@@ -1018,8 +1069,8 @@
     }
     const QVariant data = document.toVariant();
     const QVariantMap map = data.toMap();
-    if (!map.contains(QStringLiteral("kind")) ||
-        map[QStringLiteral("kind")].toString() != QLatin1String("drive#fileList"))
+    if (!map.contains(File::Fields::Kind) ||
+        map[Fields::Kind].toString() != QLatin1String("drive#fileList"))
     {
         return FilesList();
     }
@@ -1034,8 +1085,8 @@
         }
     }
 
-    if (map.contains(QStringLiteral("nextLink"))) {
-        feedData.nextPageUrl = map[QStringLiteral("nextLink")].toUrl();
+    if (map.contains(File::Fields::NextLink)) {
+        feedData.nextPageUrl = map[File::Fields::NextLink].toUrl();
     }
 
     return list;
@@ -1045,15 +1096,15 @@
 {
     QVariantMap map;
 
-    map[QStringLiteral("kind")] = QLatin1String("drive#file");
+    map[File::Fields::Kind] = QLatin1String("drive#file");
     if (!file->description().isEmpty()) {
-        map[QStringLiteral("description")] = file->description();
+        map[Fields::Description] = file->description();
     }
 
     if (file->indexableText() && !file->indexableText()->text().isEmpty()) {
         QVariantMap indexableText;
         indexableText[QStringLiteral("text")] = file->indexableText()->text();
-        map[QStringLiteral("indexableText")] = indexableText;
+        map[Fields::IndexableText] = indexableText;
     }
 
     if (file->labels()) {
@@ -1063,33 +1114,33 @@
         labels[QStringLiteral("starred")] = file->labels()->starred();
         labels[QStringLiteral("trashed")] = file->labels()->trashed();
         labels[QStringLiteral("viewed")] = file->labels()->viewed();
-        map[QStringLiteral("labels")] = labels;
+        map[Fields::Labels] = labels;
     }
 
     if (file->lastViewedByMeDate().isValid()) {
-        map[QStringLiteral("lastViewedByMeDate")] = file->lastViewedByMeDate().toString(Qt::ISODate);
+        map[Fields::LastViewedByMeDate] = file->lastViewedByMeDate().toString(Qt::ISODate);
     }
 
     if (!file->mimeType().isEmpty()) {
-        map[QStringLiteral("mimeType")] = file->mimeType();
+        map[Fields::MimeType] = file->mimeType();
     }
 
     if (file->modifiedDate().isValid()) {
-        map[QStringLiteral("modifiedDate")] = file->modifiedDate().toString(Qt::ISODate);
+        map[Fields::ModifiedDate] = file->modifiedDate().toString(Qt::ISODate);
     }
     if (file->createdDate().isValid() && !(options & ExcludeCreationDate)) {
-        map[QStringLiteral("createdDate")] = file->createdDate().toString(Qt::ISODate);
+        map[Fields::CreatedDate] = file->createdDate().toString(Qt::ISODate);
     }
     if (file->modifiedByMeDate().isValid()) {
-        map[QStringLiteral("modifiedByMeDate")] = file->modifiedByMeDate().toString(Qt::ISODate);
+        map[Fields::ModifiedByMeDate] = file->modifiedByMeDate().toString(Qt::ISODate);
     }
 
     if (file->fileSize() > 0) {
-        map[QStringLiteral("fileSize")] = file->fileSize();
+        map[Fields::FileSize] = file->fileSize();
     }
 
     if (!file->title().isEmpty()) {
-        map[QStringLiteral("title")] = file->title();
+        map[Fields::Title] = file->title();
     }
 
     QVariantList parents;
@@ -1099,35 +1150,35 @@
         parents << ParentReference::Private::toJSON(parent);
     }
     if (!parents.isEmpty()) {
-        map[QStringLiteral("parents")] = parents;
+        map[Fields::Parents] = parents;
     }
     if (!file->etag().isEmpty()) {
-        map[QStringLiteral("etag")] = file->etag();
+        map[Fields::Etag] = file->etag();
     }
     if (!file->d->id.isEmpty()) {
-        map[QStringLiteral("id")] = file->d->id;
+        map[Fields::Id] = file->d->id;
     }
     if (!file->d->selfLink.isEmpty()) {
-        map[QStringLiteral("selfLink")] = file->d->selfLink;
+        map[Fields::SelfLink] = file->d->selfLink;
     }
     if (!file->d->downloadUrl.isEmpty()) {
-        map[QStringLiteral("downloadUrl")] = file->d->downloadUrl;
+        map[Fields::DownloadUrl] = file->d->downloadUrl;
     }
 
     if (!file->d->fileExtension.isEmpty()) {
-        map[QStringLiteral("fileExtension")] = file->d->fileExtension;
+        map[Fields::FileExtension] = file->d->fileExtension;
     }
     if (!file->d->md5Checksum.isEmpty()) {
-        map[QStringLiteral("md5Checksum")] = file->d->md5Checksum;
+        map[Fields::Md5Checksum] = file->d->md5Checksum;
     }
     if (!file->d->alternateLink.isEmpty()) {
-        map[QStringLiteral("alternateLink")] = file->d->alternateLink;
+        map[Fields::AlternateLink] = file->d->alternateLink;
     }
     if (!file->d->embedLink.isEmpty()) {
-        map[QStringLiteral("embedLink")] = file->d->embedLink;
+        map[Fields::EmbedLink] = file->d->embedLink;
     }
     if (!file->d->sharedWithMeDate.isNull()) {
-        map[QStringLiteral("sharedWithMeDate")] = file->d->sharedWithMeDate.toString(Qt::ISODate);
+        map[Fields::SharedWithMeDate] = file->d->sharedWithMeDate.toString(Qt::ISODate);
     }
 
 
@@ -1138,38 +1189,38 @@
         map[QStringLiteral("quotaBytesUsed")] = file->d->quotaBytesUsed;
     }
     if (!file->d->ownerNames.isEmpty()) {
-        map[QStringLiteral("ownerNames")] = QVariant(file->d->ownerNames);
+        map[Fields::OwnerNames] = QVariant(file->d->ownerNames);
     }
     if (!file->d->lastModifyingUserName.isEmpty()) {
         map[QStringLiteral("lastModifyingUserName")] = file->d->lastModifyingUserName;
     }
     if (!file->d->editable) { // default is true
-        map[QStringLiteral("editable")] = file->d->editable;
+        map[Fields::Editable] = file->d->editable;
     }
     if (file->d->writersCanShare) { // default is false
-        map[QStringLiteral("writersCanShare")] = file->d->writersCanShare;
+        map[Fields::WritersCanShare] = file->d->writersCanShare;
     }
     if (!file->d->thumbnailLink.isEmpty()) {
-        map[QStringLiteral("thumbnailLink")] = file->d->thumbnailLink;
+        map[Fields::ThumbnailLink] = file->d->thumbnailLink;
     }
     if (!file->d->lastViewedByMeDate.isNull()) {
-        map[QStringLiteral("lastViewedByMeDate")] = file->d->lastViewedByMeDate.toString(Qt::ISODate);
+        map[Fields::LastViewedByMeDate] = file->d->lastViewedByMeDate.toString(Qt::ISODate);
     }
     if (!file->d->webContentLink.isEmpty()) {
-        map[QStringLiteral("webContentLink")] = file->d->webContentLink;
+        map[Fields::WebContentLink] = file->d->webContentLink;
     }
     if (file->d->explicitlyTrashed) {
-        map[QStringLiteral("explicitlyTrashed")] = file->d->explicitlyTrashed;
+        map[Fields::ExplicitlyTrashed] = file->d->explicitlyTrashed;
     }
 
     if (!file->d->webViewLink.isEmpty()) {
-        map[QStringLiteral("webViewLink")] = file->d->webViewLink;
+        map[Fields::WebViewLink] = file->d->webViewLink;
     }
     if (!file->d->iconLink.isEmpty()) {
-        map[QStringLiteral("iconLink")] = file->d->iconLink;
+        map[Fields::IconLink] = file->d->iconLink;
     }
     if (file->d->shared) {
-        map[QStringLiteral("shared")] = file->d->shared;
+        map[Fields::Shared] = file->d->shared;
     }
 
 #if 0
@@ -1211,9 +1262,3 @@
     QJsonDocument document = QJsonDocument::fromVariant(map);
     return document.toJson(QJsonDocument::Compact);
 }
-
-
-
-
-
-
diff --git a/src/drive/filefetchjob.h b/src/drive/filefetchjob.h
--- a/src/drive/filefetchjob.h
+++ b/src/drive/filefetchjob.h
@@ -51,58 +51,10 @@
                WRITE setUpdateViewedDate)
 
   public:
-    enum Fields {
-        AllFields                     = 0ULL,
-        Id                            = 1ULL << 0,
-        Title                         = 1ULL << 1,
-        MimeType                      = 1ULL << 2,
-        Description                   = 1ULL << 3,
-        Labels                        = 1ULL << 4,
-        CreatedDate                   = 1ULL << 5,
-        ModifiedDate                  = 1ULL << 6,
-        ModifiedByMeDate              = 1ULL << 7,
-        DownloadUrl                   = 1ULL << 8,
-        IndexableText                 = 1ULL << 9,
-        UserPermission                = 1ULL << 10,
-        FileExtension                 = 1ULL << 11,
-        MD5Checksum                   = 1ULL << 12,
-        FileSize                      = 1ULL << 13,
-        AlternateLink                 = 1ULL << 14,
-        EmbedLink                     = 1ULL << 15,
-        SharedWithMeDate              = 1ULL << 16,
-        Parents                       = 1ULL << 17,
-        ExportLinks                   = 1ULL << 18,
-        OriginalFilename              = 1ULL << 19,
-        OwnerNames                    = 1ULL << 20,
-        LastModifiedByMeDate          = 1ULL << 21,
-        Editable                      = 1ULL << 22,
-        WritersCanShare               = 1ULL << 23,
-        ThumbnailLink                 = 1ULL << 24,
-        LastViewedByMeDate            = 1ULL << 25,
-        WebContentLink                = 1ULL << 26,
-        ExplicitlyTrashed             = 1ULL << 27,
-        ImageMediaMetadata            = 1ULL << 28,
-        Thumbnail                     = 1ULL << 29,
-        WebViewLink                   = 1ULL << 30,
-        IconLink                      = 1ULL << 31,
-        Shared                        = 1ULL << 32,
-        Owners                        = 1ULL << 33,
-        LastModifyingUser             = 1ULL << 34,
-        AppDataContents               = 1ULL << 35,
-        OpenWithLinks                 = 1ULL << 36,
-        DefaultOpenWithLink           = 1ULL << 37,
-        HeadRevisionId                = 1ULL << 38,
-        Copyable                      = 1ULL << 39,
-        Properties                    = 1ULL << 40,
-        MarkedViewedByMeDate          = 1ULL << 41,
-        Version                       = 1ULL << 42,
-        SharingUser                   = 1ULL << 43,
-        Permissions                   = 1ULL << 44,
-
-        BasicFields        = Id | Title | MimeType | CreatedDate | ModifiedDate | FileSize | DownloadUrl | Permissions,
-        AccessFields       = CreatedDate | ModifiedDate | ModifiedByMeDate | LastModifiedByMeDate | LastViewedByMeDate | MarkedViewedByMeDate,
-        SharingFields      = SharedWithMeDate | WritersCanShare | Shared | Owners | SharingUser | OwnerNames
-        // TODO: More?
+    struct FieldShorthands {
+        static const QStringList BasicFields;
+        static const QStringList AccessFields;
+        static const QStringList SharingFields;
     };
 
     explicit FileFetchJob(const QString &fileId,
@@ -114,12 +66,12 @@
     explicit FileFetchJob(const AccountPtr &account, QObject *parent = nullptr);
     ~FileFetchJob() override;
 
+    void setFields(const QStringList &fields);
+    QStringList fields() const;
+
     bool updateViewedDate() const;
     void setUpdateViewedDate(bool updateViewedDate);
 
-    void setFields(qulonglong fields);
-    qulonglong fields() const;
-
     /**
      * @brief Whether both My Drive and shared drive items should be included in results.
      *
diff --git a/src/drive/filefetchjob.cpp b/src/drive/filefetchjob.cpp
--- a/src/drive/filefetchjob.cpp
+++ b/src/drive/filefetchjob.cpp
@@ -40,7 +40,6 @@
   public:
     Private(FileFetchJob *parent);
     void processNext();
-    QStringList fieldsToStrings(qulonglong fields);
 
     FileSearchQuery searchQuery;
     QStringList filesIDs;
@@ -50,7 +49,7 @@
 
     bool updateViewedDate;
 
-    qulonglong fields;
+    QStringList fields;
 
   private:
     FileFetchJob *const q;
@@ -61,182 +60,42 @@
     includeItemsFromAllDrives(true),
     supportsAllDrives(true),
     updateViewedDate(false),
-    fields(FileFetchJob::AllFields),
     q(parent)
 {
 }
 
-
-QStringList FileFetchJob::Private::fieldsToStrings(qulonglong fields)
-{
-    if (fields & AllFields) {
-        return QStringList();
-    }
-
-    QStringList fieldsStrings;
-    // Always fetch kind
-    fieldsStrings << QStringLiteral("kind");
-
-    // FIXME: Use QMetaEnum once it supports enums larger than int
-    if (fields & Id) {
-        fieldsStrings << QStringLiteral("id");
-    }
-    if (fields & Title) {
-        fieldsStrings << QStringLiteral("title");
-    }
-    if (fields & MimeType) {
-        fieldsStrings << QStringLiteral("mimeType");
-    }
-    if (fields & Description) {
-        fieldsStrings << QStringLiteral("description");
-    }
-    if (fields & Labels) {
-        fieldsStrings << QStringLiteral("labels");
-    }
-    if (fields & CreatedDate) {
-        fieldsStrings << QStringLiteral("createdDate");
-    }
-    if (fields & ModifiedDate) {
-        fieldsStrings << QStringLiteral("modifiedDate");
-    }
-    if (fields & ModifiedByMeDate) {
-        fieldsStrings << QStringLiteral("modifiedByMeDate");
-    }
-    if (fields & DownloadUrl) {
-        fieldsStrings << QStringLiteral("downloadUrl");
-    }
-    if (fields & IndexableText) {
-        fieldsStrings << QStringLiteral("indexableText");
-    }
-    if (fields & UserPermission) {
-        fieldsStrings << QStringLiteral("userPermission");
-    }
-    if (fields & FileExtension) {
-        fieldsStrings << QStringLiteral("fileExtension");
-    }
-    if (fields & MD5Checksum) {
-        fieldsStrings << QStringLiteral("md5Checksum");
-    }
-    if (fields & FileSize) {
-        fieldsStrings << QStringLiteral("fileSize");
-    }
-    if (fields & AlternateLink) {
-        fieldsStrings << QStringLiteral("alternateLink");
-    }
-    if (fields & EmbedLink) {
-        fieldsStrings << QStringLiteral("embedLink");
-    }
-    if (fields & SharedWithMeDate) {
-        fieldsStrings << QStringLiteral("sharedWithMeDate");
-    }
-    if (fields & Parents) {
-        fieldsStrings << QStringLiteral("parents");
-    }
-    if (fields & ExportLinks) {
-        fieldsStrings << QStringLiteral("exportLinks");
-    }
-    if (fields & OriginalFilename) {
-        fieldsStrings << QStringLiteral("originalFilename");
-    }
-    if (fields & OwnerNames) {
-        fieldsStrings << QStringLiteral("ownerNames");
-    }
-    if (fields & LastModifiedByMeDate) {
-        fieldsStrings << QStringLiteral("lastModifiedByMeDate");
-    }
-    if (fields & Editable) {
-        fieldsStrings << QStringLiteral("editable");
-    }
-    if (fields & WritersCanShare) {
-        fieldsStrings << QStringLiteral("writersCanShare");
-    }
-    if (fields & ThumbnailLink) {
-        fieldsStrings << QStringLiteral("thumbnailLink");
-    }
-    if (fields & LastViewedByMeDate) {
-        fieldsStrings << QStringLiteral("lastViewedByMeDate");
-    }
-    if (fields & WebContentLink) {
-        fieldsStrings << QStringLiteral("webContentLink");
-    }
-    if (fields & ExplicitlyTrashed) {
-        fieldsStrings << QStringLiteral("explicitlyTrashed");
-    }
-    if (fields & ImageMediaMetadata) {
-        fieldsStrings << QStringLiteral("imageMediaMetadata");
-    }
-    if (fields & Thumbnail) {
-        fieldsStrings << QStringLiteral("thumbnail");
-    }
-    if (fields & WebViewLink) {
-        fieldsStrings << QStringLiteral("webViewLink");
-    }
-    if (fields & IconLink) {
-        fieldsStrings << QStringLiteral("iconLink");
-    }
-    if (fields & Shared) {
-        fieldsStrings << QStringLiteral("shared");
-    }
-    if (fields & Owners) {
-        fieldsStrings << QStringLiteral("owners");
-    }
-    if (fields & LastModifyingUser) {
-        fieldsStrings << QStringLiteral("lastModifyingUser");
-    }
-    if (fields & AppDataContents) {
-        fieldsStrings << QStringLiteral("appDataContents");
-    }
-    if (fields & OpenWithLinks) {
-        fieldsStrings << QStringLiteral("openWithLinks");
-    }
-    if (fields & DefaultOpenWithLink) {
-        fieldsStrings << QStringLiteral("defaultOpenWithLink");
-    }
-    if (fields & HeadRevisionId) {
-        fieldsStrings << QStringLiteral("headRevisionId");
-    }
-    if (fields & Copyable) {
-        fieldsStrings << QStringLiteral("copyable");
-    }
-    if (fields & Properties) {
-        fieldsStrings << QStringLiteral("properties");
-    }
-    if (fields & MarkedViewedByMeDate) {
-        fieldsStrings << QStringLiteral("markedViewedByMeDate");
-    }
-    if (fields & Version) {
-        fieldsStrings << QStringLiteral("version");
-    }
-    if (fields & SharingUser) {
-        fieldsStrings << QStringLiteral("sharingUser");
-    }
-    if (fields & Permissions) {
-        fieldsStrings << QStringLiteral("permissions");
-    }
-
-    return fieldsStrings;
-}
-
-
 void FileFetchJob::Private::processNext()
 {
     QUrl url;
 
     if (isFeed) {
         url = DriveService::fetchFilesUrl();
+
         QUrlQuery query(url);
         if (!searchQuery.isEmpty()) {
             query.addQueryItem(QStringLiteral("q"), searchQuery.serialize());
         }
-        if (fields != FileFetchJob::AllFields) {
-            const QStringList fieldsStrings = fieldsToStrings(fields);
-            query.addQueryItem(QStringLiteral("fields"),
-                             QStringLiteral("etag,kind,nextLink,nextPageToken,selfLink,items(%1)").arg(fieldsStrings.join(QStringLiteral(","))));
-        }
 
         query.addQueryItem(QStringLiteral("includeItemsFromAllDrives"), includeItemsFromAllDrives ? QStringLiteral("true") : QStringLiteral("false"));
 
         url.setQuery(query);
+
+        if (!fields.isEmpty()) {
+            // Deserializing requires kind attribute, always force add it
+            if (!fields.contains(File::Fields::Kind)) {
+                fields << File::Fields::Kind;
+            }
+            QString itemFields = QStringLiteral("items(%1)").arg(fields.join(QStringLiteral(",")));
+            Job *baseJob = dynamic_cast<Job *>(q);
+            baseJob->setFields({
+                File::Fields::Etag,
+                File::Fields::Kind,
+                File::Fields::NextLink,
+                File::Fields::NextPageToken,
+                File::Fields::SelfLink,
+                itemFields
+            });
+        }
     } else {
         if (filesIDs.isEmpty()) {
             q->emitFinished();
@@ -245,11 +104,14 @@
 
         const QString fileId = filesIDs.takeFirst();
         url = DriveService::fetchFileUrl(fileId);
-        if (fields != FileFetchJob::AllFields) {
-            const QStringList fieldsStrings = fieldsToStrings(fields);
-            QUrlQuery query(url);
-            query.addQueryItem(QStringLiteral("fields"), fieldsStrings.join(QStringLiteral(",")));
-            url.setQuery(query);
+
+        if (!fields.isEmpty()) {
+            // Deserializing requires kind attribute, always force add it
+            if (!fields.contains(File::Fields::Kind)) {
+                fields << File::Fields::Kind;
+            }
+            Job *baseJob = dynamic_cast<Job *>(q);
+            baseJob->setFields(fields);
         }
     }
 
@@ -319,12 +181,17 @@
     d->processNext();
 }
 
-void FileFetchJob::setFields(qulonglong fields)
+void FileFetchJob::setFields(const QStringList &fields)
 {
+    if (isRunning()) {
+        qCWarning(KGAPIDebug) << "Called setFields() on running job. Ignoring.";
+        return;
+    }
+
     d->fields = fields;
 }
 
-qulonglong FileFetchJob::fields() const
+QStringList FileFetchJob::fields() const
 {
     return d->fields;
 }
@@ -349,6 +216,34 @@
     d->supportsAllDrives = supportsAllDrives;
 }
 
+const QStringList FileFetchJob::FieldShorthands::BasicFields = {
+    File::Fields::Id,
+    File::Fields::Title,
+    File::Fields::MimeType,
+    File::Fields::CreatedDate,
+    File::Fields::ModifiedDate,
+    File::Fields::FileSize,
+    File::Fields::DownloadUrl,
+    File::Fields::Permissions
+};
+
+const QStringList FileFetchJob::FieldShorthands::AccessFields = {
+    File::Fields::CreatedDate,
+    File::Fields::ModifiedDate,
+    File::Fields::ModifiedByMeDate,
+    File::Fields::LastModifiedByMeDate,
+    File::Fields::LastViewedByMeDate,
+    File::Fields::MarkedViewedByMeDate
+};
+
+const QStringList FileFetchJob::FieldShorthands::SharingFields = {
+    File::Fields::SharedWithMeDate,
+    File::Fields::WritersCanShare,
+    File::Fields::Shared,
+    File::Fields::Owners,
+    File::Fields::SharingUser,
+    File::Fields::OwnerNames
+};
 
 ObjectsList FileFetchJob::handleReplyWithItems(const QNetworkReply *reply,
                                                const QByteArray &rawData)
diff --git a/src/drive/teamdrive.h b/src/drive/teamdrive.h
--- a/src/drive/teamdrive.h
+++ b/src/drive/teamdrive.h
@@ -57,6 +57,13 @@
     {
 
       public:
+        struct Fields {
+            static const QString AdminManagedRestrictions;
+            static const QString CopyRequiresWriterPermission;
+            static const QString DomainUsersOnly;
+            static const QString TeamMembersOnly;
+        };
+
         Restrictions();
         Restrictions(const Restrictions &other);
         ~Restrictions();
@@ -143,6 +150,27 @@
     {
 
       public:
+        struct Fields {
+            static const QString CanAddChildren;
+            static const QString CanChangeCopyRequiresWriterPermissionRestriction;
+            static const QString CanChangeDomainUsersOnlyRestriction;
+            static const QString CanChangeTeamDriveBackground;
+            static const QString CanChangeTeamMembersOnlyRestriction;
+            static const QString CanComment;
+            static const QString CanCopy;
+            static const QString CanDeleteChildren;
+            static const QString CanDeleteTeamDrive;
+            static const QString CanDownload;
+            static const QString CanEdit;
+            static const QString CanListChildren;
+            static const QString CanManageMembers;
+            static const QString CanReadRevisions;
+            static const QString CanRename;
+            static const QString CanRenameTeamDrive;
+            static const QString CanShare;
+            static const QString CanTrashChildren;
+        };
+
         Capabilities();
         Capabilities(const Capabilities &other);
         ~Capabilities();
@@ -274,6 +302,13 @@
     {
 
       public:
+        struct Fields {
+            static const QString Id;
+            static const QString XCoordinate;
+            static const QString YCoordinate;
+            static const QString Width;
+        };
+
         BackgroundImageFile();
         BackgroundImageFile(const BackgroundImageFile &other);
         ~BackgroundImageFile();
@@ -337,6 +372,23 @@
 
     typedef QSharedPointer<BackgroundImageFile> BackgroundImageFilePtr;
 
+    struct Fields {
+        static const QString Kind;
+        static const QString Items;
+        static const QString KindDrive;
+        static const QString PageToken;
+        static const QString NextPageToken;
+        static const QString Id;
+        static const QString Name;
+        static const QString ThemeId;
+        static const QString ColorRgb;
+        static const QString BackgroundImageFile;
+        static const QString BackgroundImageLink;
+        static const QString Capabilities;
+        static const QString CreatedDate;
+        static const QString Restrictions;
+    };
+
     Teamdrive();
     Teamdrive(const Teamdrive &other);
     ~Teamdrive() override;
diff --git a/src/drive/teamdrive.cpp b/src/drive/teamdrive.cpp
--- a/src/drive/teamdrive.cpp
+++ b/src/drive/teamdrive.cpp
@@ -29,45 +29,6 @@
 namespace {
     static const QString ApiKind = QStringLiteral("drive#teamDrive");
     static const QString ApiKindList = QStringLiteral("drive#teamDriveList");
-    static const QString AdminManagedRestrictionsAttr = QStringLiteral("adminManagedRestrictions");
-    static const QString BackgroundImageFileAttr = QStringLiteral("backgroundImageFile");
-    static const QString BackgroundImageLinkAttr = QStringLiteral("backgroundImageLink");
-    static const QString CanAddChildrenAttr = QStringLiteral("canAddChildren");
-    static const QString CanChangeCopyRequiresWriterPermissionRestrictionAttr = QStringLiteral("canChangeCopyRequiresWriterPermissionRestriction");
-    static const QString CanChangeDomainUsersOnlyRestrictionAttr = QStringLiteral("canChangeDomainUsersOnlyRestriction");
-    static const QString CanChangeTeamDriveBackgroundAttr = QStringLiteral("canChangeTeamDriveBackground");
-    static const QString CanChangeTeamMembersOnlyRestrictionAttr = QStringLiteral("canChangeTeamMembersOnlyRestriction");
-    static const QString CanCommentAttr = QStringLiteral("canComment");
-    static const QString CanCopyAttr = QStringLiteral("canCopy");
-    static const QString CanDeleteChildrenAttr = QStringLiteral("canDeleteChildren");
-    static const QString CanDeleteTeamDriveAttr = QStringLiteral("canDeleteTeamDrive");
-    static const QString CanDownloadAttr = QStringLiteral("canDownload");
-    static const QString CanEditAttr = QStringLiteral("canEdit");
-    static const QString CanListChildrenAttr = QStringLiteral("canListChildren");
-    static const QString CanManageMembersAttr = QStringLiteral("canManageMembers");
-    static const QString CanReadRevisionsAttr = QStringLiteral("canReadRevisions");
-    static const QString CanRenameAttr = QStringLiteral("canRename");
-    static const QString CanRenameTeamDriveAttr = QStringLiteral("canRenameTeamDrive");
-    static const QString CanShareAttr = QStringLiteral("canShare");
-    static const QString CanTrashChildrenAttr = QStringLiteral("canTrashChildren");
-    static const QString CapabilitiesAttr = QStringLiteral("capabilities");
-    static const QString ColorRgbAttr = QStringLiteral("colorRgb");
-    static const QString CopyRequiresWriterPermissionAttr = QStringLiteral("copyRequiresWriterPermission");
-    static const QString CreatedDateAttr = QStringLiteral("createdDate");
-    static const QString DomainUsersOnlyAttr = QStringLiteral("domainUsersOnly");
-    static const QString IdAttr = QStringLiteral("id");
-    static const QString ItemsAttr = QStringLiteral("items");
-    static const QString KindAttr = QStringLiteral("kind");
-    static const QString KindDriveAttr = QStringLiteral("kind");
-    static const QString NameAttr = QStringLiteral("name");
-    static const QString PageTokenAttr = QStringLiteral("pageToken");
-    static const QString NextPageTokenAttr = QStringLiteral("nextPageToken");
-    static const QString RestrictionsAttr = QStringLiteral("restrictions");
-    static const QString TeamMembersOnlyAttr = QStringLiteral("teamMembersOnly");
-    static const QString ThemeIdAttr = QStringLiteral("themeId");
-    static const QString WidthAttr = QStringLiteral("width");
-    static const QString XCoordinateAttr = QStringLiteral("xCoordinate");
-    static const QString YCoordinateAttr = QStringLiteral("yCoordinate");
 }
 
 using namespace KGAPI2;
@@ -399,79 +360,123 @@
 
 TeamdrivePtr Teamdrive::Private::fromJSON(const QVariantMap &map)
 {
-    if (!map.contains(KindAttr) ||
-        map[KindAttr].toString() != ApiKind)
+    if (!map.contains(Teamdrive::Fields::Kind) ||
+        map[Teamdrive::Fields::Kind].toString() != ApiKind)
     {
         return TeamdrivePtr();
     }
 
     auto teamdrive = TeamdrivePtr::create();
-    if (map.contains(IdAttr)) {
-        teamdrive->d->id = map[IdAttr].toString();
+    if (map.contains(Teamdrive::Fields::Id)) {
+        teamdrive->d->id = map[Teamdrive::Fields::Id].toString();
     }
-    if (map.contains(NameAttr)) {
-        teamdrive->d->name = map[NameAttr].toString();
+    if (map.contains(Teamdrive::Fields::Name)) {
+        teamdrive->d->name = map[Teamdrive::Fields::Name].toString();
     }
-    if (map.contains(ThemeIdAttr)) {
-        teamdrive->d->themeId = map[ThemeIdAttr].toString();
+    if (map.contains(Teamdrive::Fields::ThemeId)) {
+        teamdrive->d->themeId = map[Teamdrive::Fields::ThemeId].toString();
     }
-    if (map.contains(ColorRgbAttr)) {
-        teamdrive->d->colorRgb = map[ColorRgbAttr].toString();
+    if (map.contains(Teamdrive::Fields::ColorRgb)) {
+        teamdrive->d->colorRgb = map[Teamdrive::Fields::ColorRgb].toString();
     }
-    if (map.contains(BackgroundImageLinkAttr)) {
-        teamdrive->d->backgroundImageLink = map[BackgroundImageLinkAttr].toString();
+    if (map.contains(Teamdrive::Fields::BackgroundImageLink)) {
+        teamdrive->d->backgroundImageLink = map[Teamdrive::Fields::BackgroundImageLink].toString();
     }
-    if (map.contains(CreatedDateAttr)) {
-        teamdrive->d->createdDate = QDateTime::fromString(map[CreatedDateAttr].toString(), Qt::ISODate);
+    if (map.contains(Teamdrive::Fields::CreatedDate)) {
+        teamdrive->d->createdDate = QDateTime::fromString(map[Teamdrive::Fields::CreatedDate].toString(), Qt::ISODate);
     }
 
-    if (map.contains(BackgroundImageFileAttr)) {
-        const QVariantMap backgroundImageFileMap = map[BackgroundImageFileAttr].toMap();
+    if (map.contains(Teamdrive::Fields::BackgroundImageFile)) {
+        const QVariantMap backgroundImageFileMap = map[Teamdrive::Fields::BackgroundImageFile].toMap();
         auto backgroundImageFile = BackgroundImageFilePtr::create();
-        backgroundImageFile->d->id = backgroundImageFileMap[IdAttr].toString();
-        backgroundImageFile->d->xCoordinate = backgroundImageFileMap[XCoordinateAttr].toReal();
-        backgroundImageFile->d->yCoordinate = backgroundImageFileMap[YCoordinateAttr].toReal();
-        backgroundImageFile->d->width = backgroundImageFileMap[WidthAttr].toReal();
+        backgroundImageFile->d->id = backgroundImageFileMap[Teamdrive::BackgroundImageFile::Fields::Id].toString();
+        backgroundImageFile->d->xCoordinate = backgroundImageFileMap[Teamdrive::BackgroundImageFile::Fields::XCoordinate].toReal();
+        backgroundImageFile->d->yCoordinate = backgroundImageFileMap[Teamdrive::BackgroundImageFile::Fields::YCoordinate].toReal();
+        backgroundImageFile->d->width = backgroundImageFileMap[Teamdrive::BackgroundImageFile::Fields::Width].toReal();
         teamdrive->d->backgroundImageFile = backgroundImageFile;
     }
 
-    if (map.contains(CapabilitiesAttr)) {
-        const QVariantMap capabilitiesMap = map[CapabilitiesAttr].toMap();
+    if (map.contains(Teamdrive::Fields::Capabilities)) {
+        const QVariantMap capabilitiesMap = map[Teamdrive::Fields::Capabilities].toMap();
         auto capabilities = CapabilitiesPtr::create();
-        capabilities->d->canAddChildren = capabilitiesMap[CanAddChildrenAttr].toBool();
-        capabilities->d->canChangeCopyRequiresWriterPermissionRestriction = capabilitiesMap[CanChangeCopyRequiresWriterPermissionRestrictionAttr].toBool();
-        capabilities->d->canChangeDomainUsersOnlyRestriction = capabilitiesMap[CanChangeDomainUsersOnlyRestrictionAttr].toBool();
-        capabilities->d->canChangeTeamDriveBackground = capabilitiesMap[CanChangeTeamDriveBackgroundAttr].toBool();
-        capabilities->d->canChangeTeamMembersOnlyRestriction = capabilitiesMap[CanChangeTeamMembersOnlyRestrictionAttr].toBool();
-        capabilities->d->canComment = capabilitiesMap[CanCommentAttr].toBool();
-        capabilities->d->canCopy = capabilitiesMap[CanCopyAttr].toBool();
-        capabilities->d->canDeleteChildren = capabilitiesMap[CanDeleteChildrenAttr].toBool();
-        capabilities->d->canDeleteTeamDrive = capabilitiesMap[CanDeleteTeamDriveAttr].toBool();
-        capabilities->d->canDownload = capabilitiesMap[CanDownloadAttr].toBool();
-        capabilities->d->canEdit = capabilitiesMap[CanEditAttr].toBool();
-        capabilities->d->canListChildren = capabilitiesMap[CanListChildrenAttr].toBool();
-        capabilities->d->canManageMembers = capabilitiesMap[CanManageMembersAttr].toBool();
-        capabilities->d->canReadRevisions = capabilitiesMap[CanReadRevisionsAttr].toBool();
-        capabilities->d->canRename = capabilitiesMap[CanRenameAttr].toBool();
-        capabilities->d->canRenameTeamDrive = capabilitiesMap[CanRenameTeamDriveAttr].toBool();
-        capabilities->d->canShare = capabilitiesMap[CanShareAttr].toBool();
-        capabilities->d->canTrashChildren = capabilitiesMap[CanTrashChildrenAttr].toBool();
+        capabilities->d->canAddChildren = capabilitiesMap[Teamdrive::Capabilities::Fields::CanAddChildren].toBool();
+        capabilities->d->canChangeCopyRequiresWriterPermissionRestriction = capabilitiesMap[Teamdrive::Capabilities::Fields::CanChangeCopyRequiresWriterPermissionRestriction].toBool();
+        capabilities->d->canChangeDomainUsersOnlyRestriction = capabilitiesMap[Teamdrive::Capabilities::Fields::CanChangeDomainUsersOnlyRestriction].toBool();
+        capabilities->d->canChangeTeamDriveBackground = capabilitiesMap[Teamdrive::Capabilities::Fields::CanChangeTeamDriveBackground].toBool();
+        capabilities->d->canChangeTeamMembersOnlyRestriction = capabilitiesMap[Teamdrive::Capabilities::Fields::CanChangeTeamMembersOnlyRestriction].toBool();
+        capabilities->d->canComment = capabilitiesMap[Teamdrive::Capabilities::Fields::CanComment].toBool();
+        capabilities->d->canCopy = capabilitiesMap[Teamdrive::Capabilities::Fields::CanCopy].toBool();
+        capabilities->d->canDeleteChildren = capabilitiesMap[Teamdrive::Capabilities::Fields::CanDeleteChildren].toBool();
+        capabilities->d->canDeleteTeamDrive = capabilitiesMap[Teamdrive::Capabilities::Fields::CanDeleteTeamDrive].toBool();
+        capabilities->d->canDownload = capabilitiesMap[Teamdrive::Capabilities::Fields::CanDownload].toBool();
+        capabilities->d->canEdit = capabilitiesMap[Teamdrive::Capabilities::Fields::CanEdit].toBool();
+        capabilities->d->canListChildren = capabilitiesMap[Teamdrive::Capabilities::Fields::CanListChildren].toBool();
+        capabilities->d->canManageMembers = capabilitiesMap[Teamdrive::Capabilities::Fields::CanManageMembers].toBool();
+        capabilities->d->canReadRevisions = capabilitiesMap[Teamdrive::Capabilities::Fields::CanReadRevisions].toBool();
+        capabilities->d->canRename = capabilitiesMap[Teamdrive::Capabilities::Fields::CanRename].toBool();
+        capabilities->d->canRenameTeamDrive = capabilitiesMap[Teamdrive::Capabilities::Fields::CanRenameTeamDrive].toBool();
+        capabilities->d->canShare = capabilitiesMap[Teamdrive::Capabilities::Fields::CanShare].toBool();
+        capabilities->d->canTrashChildren = capabilitiesMap[Teamdrive::Capabilities::Fields::CanTrashChildren].toBool();
         teamdrive->d->capabilities = capabilities;
     }
 
-    if (map.contains(RestrictionsAttr)) {
-        const QVariantMap restrictionsMap = map[RestrictionsAttr].toMap();
+    if (map.contains(Teamdrive::Fields::Restrictions)) {
+        const QVariantMap restrictionsMap = map[Teamdrive::Fields::Restrictions].toMap();
         auto restrictions = RestrictionsPtr::create();
-        restrictions->d->adminManagedRestrictions = restrictionsMap[AdminManagedRestrictionsAttr].toBool();
-        restrictions->d->copyRequiresWriterPermission = restrictionsMap[CopyRequiresWriterPermissionAttr].toBool();
-        restrictions->d->domainUsersOnly = restrictionsMap[DomainUsersOnlyAttr].toBool();
-        restrictions->d->teamMembersOnly = restrictionsMap[TeamMembersOnlyAttr].toBool();
+        restrictions->d->adminManagedRestrictions = restrictionsMap[Teamdrive::Restrictions::Fields::AdminManagedRestrictions].toBool();
+        restrictions->d->copyRequiresWriterPermission = restrictionsMap[Teamdrive::Restrictions::Fields::CopyRequiresWriterPermission].toBool();
+        restrictions->d->domainUsersOnly = restrictionsMap[Teamdrive::Restrictions::Fields::DomainUsersOnly].toBool();
+        restrictions->d->teamMembersOnly = restrictionsMap[Teamdrive::Restrictions::Fields::TeamMembersOnly].toBool();
         teamdrive->d->restrictions = restrictions;
     }
 
     return teamdrive;
 }
 
+const QString Teamdrive::Restrictions::Fields::AdminManagedRestrictions = QStringLiteral("adminManagedRestrictions");
+const QString Teamdrive::Restrictions::Fields::CopyRequiresWriterPermission = QStringLiteral("copyRequiresWriterPermission");
+const QString Teamdrive::Restrictions::Fields::DomainUsersOnly = QStringLiteral("domainUsersOnly");
+const QString Teamdrive::Restrictions::Fields::TeamMembersOnly = QStringLiteral("teamMembersOnly");
+
+const QString Teamdrive::Capabilities::Fields::CanAddChildren = QStringLiteral("canAddChildren");
+const QString Teamdrive::Capabilities::Fields::CanChangeCopyRequiresWriterPermissionRestriction = QStringLiteral("canChangeCopyRequiresWriterPermissionRestriction");
+const QString Teamdrive::Capabilities::Fields::CanChangeDomainUsersOnlyRestriction = QStringLiteral("canChangeDomainUsersOnlyRestriction");
+const QString Teamdrive::Capabilities::Fields::CanChangeTeamDriveBackground = QStringLiteral("canChangeTeamDriveBackground");
+const QString Teamdrive::Capabilities::Fields::CanChangeTeamMembersOnlyRestriction = QStringLiteral("canChangeTeamMembersOnlyRestriction");
+const QString Teamdrive::Capabilities::Fields::CanComment = QStringLiteral("canComment");
+const QString Teamdrive::Capabilities::Fields::CanCopy = QStringLiteral("canCopy");
+const QString Teamdrive::Capabilities::Fields::CanDeleteChildren = QStringLiteral("canDeleteChildren");
+const QString Teamdrive::Capabilities::Fields::CanDeleteTeamDrive = QStringLiteral("canDeleteTeamDrive");
+const QString Teamdrive::Capabilities::Fields::CanDownload = QStringLiteral("canDownload");
+const QString Teamdrive::Capabilities::Fields::CanEdit = QStringLiteral("canEdit");
+const QString Teamdrive::Capabilities::Fields::CanListChildren = QStringLiteral("canListChildren");
+const QString Teamdrive::Capabilities::Fields::CanManageMembers = QStringLiteral("canManageMembers");
+const QString Teamdrive::Capabilities::Fields::CanReadRevisions = QStringLiteral("canReadRevisions");
+const QString Teamdrive::Capabilities::Fields::CanRename = QStringLiteral("canRename");
+const QString Teamdrive::Capabilities::Fields::CanRenameTeamDrive = QStringLiteral("canRenameTeamDrive");
+const QString Teamdrive::Capabilities::Fields::CanShare = QStringLiteral("canShare");
+const QString Teamdrive::Capabilities::Fields::CanTrashChildren = QStringLiteral("canTrashChildren");
+
+const QString Teamdrive::BackgroundImageFile::Fields::Id = QStringLiteral("id");
+const QString Teamdrive::BackgroundImageFile::Fields::XCoordinate = QStringLiteral("xCoordinate");
+const QString Teamdrive::BackgroundImageFile::Fields::YCoordinate = QStringLiteral("yCoordinate");
+const QString Teamdrive::BackgroundImageFile::Fields::Width = QStringLiteral("width");
+
+const QString Teamdrive::Fields::Items = QStringLiteral("items");
+const QString Teamdrive::Fields::KindDrive = QStringLiteral("kind");
+const QString Teamdrive::Fields::PageToken = QStringLiteral("pageToken");
+const QString Teamdrive::Fields::NextPageToken = QStringLiteral("nextPageToken");
+const QString Teamdrive::Fields::Id = QStringLiteral("id");
+const QString Teamdrive::Fields::Kind = QStringLiteral("kind");
+const QString Teamdrive::Fields::Name = QStringLiteral("name");
+const QString Teamdrive::Fields::ThemeId = QStringLiteral("themeId");
+const QString Teamdrive::Fields::ColorRgb = QStringLiteral("colorRgb");
+const QString Teamdrive::Fields::BackgroundImageFile = QStringLiteral("backgroundImageFile");
+const QString Teamdrive::Fields::BackgroundImageLink = QStringLiteral("backgroundImageLink");
+const QString Teamdrive::Fields::Capabilities = QStringLiteral("capabilities");
+const QString Teamdrive::Fields::CreatedDate = QStringLiteral("createdDate");
+const QString Teamdrive::Fields::Restrictions = QStringLiteral("restrictions");
+
 Teamdrive::Teamdrive():
     KGAPI2::Object(),
     d(new Private)
@@ -598,20 +603,20 @@
 
     const QVariant data = document.toVariant();
     const QVariantMap map = data.toMap();
-    if (!map.contains(KindAttr) ||
-            map[KindAttr].toString() != ApiKindList) {
+    if (!map.contains(Teamdrive::Fields::Kind) ||
+            map[Teamdrive::Fields::Kind].toString() != ApiKindList) {
         return TeamdrivesList();
     }
 
-    if (map.contains(NextPageTokenAttr)) {
+    if (map.contains(Teamdrive::Fields::NextPageToken)) {
         feedData.nextPageUrl = DriveService::fetchTeamdrivesUrl();
         QUrlQuery query(feedData.nextPageUrl);
-        query.addQueryItem(PageTokenAttr, map.value(NextPageTokenAttr).toString());
+        query.addQueryItem(Teamdrive::Fields::PageToken, map.value(Teamdrive::Fields::NextPageToken).toString());
         feedData.nextPageUrl.setQuery(query);
     }
 
     TeamdrivesList list;
-    const QVariantList items = map[ItemsAttr].toList();
+    const QVariantList items = map[Teamdrive::Fields::Items].toList();
     for (const QVariant & item : items) {
         const TeamdrivePtr teamdrive = Private::fromJSON(item.toMap());
 
@@ -626,65 +631,65 @@
 QByteArray Teamdrive::toJSON(const TeamdrivePtr &teamdrive)
 {
     QVariantMap teamDriveMap;
-    teamDriveMap[KindAttr] = ApiKind;
+    teamDriveMap[Teamdrive::Fields::Kind] = ApiKind;
     if (!teamdrive->id().isEmpty()) {
-        teamDriveMap[IdAttr] = teamdrive->id();
+        teamDriveMap[Teamdrive::Fields::Id] = teamdrive->id();
     }
     if (!teamdrive->name().isEmpty()) {
-        teamDriveMap[NameAttr] = teamdrive->name();
+        teamDriveMap[Teamdrive::Fields::Name] = teamdrive->name();
     }
     if (!teamdrive->themeId().isEmpty()) {
-        teamDriveMap[ThemeIdAttr] = teamdrive->themeId();
+        teamDriveMap[Teamdrive::Fields::ThemeId] = teamdrive->themeId();
     }
     if (!teamdrive->colorRgb().isEmpty()) {
-        teamDriveMap[ColorRgbAttr] = teamdrive->colorRgb();
+        teamDriveMap[Teamdrive::Fields::ColorRgb] = teamdrive->colorRgb();
     }
     if (!teamdrive->backgroundImageLink().isEmpty()) {
-        teamDriveMap[BackgroundImageLinkAttr] = teamdrive->backgroundImageLink();
+        teamDriveMap[Teamdrive::Fields::BackgroundImageLink] = teamdrive->backgroundImageLink();
     }
     if (teamdrive->createdDate().isValid()) {
-        teamDriveMap[CreatedDateAttr] = teamdrive->createdDate();
+        teamDriveMap[Teamdrive::Fields::CreatedDate] = teamdrive->createdDate();
     }
 
     if (teamdrive->restrictions()) {
         QVariantMap restrictionsMap;
-        restrictionsMap[AdminManagedRestrictionsAttr] = teamdrive->restrictions()->adminManagedRestrictions();
-        restrictionsMap[CopyRequiresWriterPermissionAttr] = teamdrive->restrictions()->copyRequiresWriterPermission();
-        restrictionsMap[DomainUsersOnlyAttr] = teamdrive->restrictions()->domainUsersOnly();
-        restrictionsMap[TeamMembersOnlyAttr] = teamdrive->restrictions()->teamMembersOnly();
-        teamDriveMap[RestrictionsAttr] = restrictionsMap;
+        restrictionsMap[Teamdrive::Restrictions::Fields::AdminManagedRestrictions] = teamdrive->restrictions()->adminManagedRestrictions();
+        restrictionsMap[Teamdrive::Restrictions::Fields::CopyRequiresWriterPermission] = teamdrive->restrictions()->copyRequiresWriterPermission();
+        restrictionsMap[Teamdrive::Restrictions::Fields::DomainUsersOnly] = teamdrive->restrictions()->domainUsersOnly();
+        restrictionsMap[Teamdrive::Restrictions::Fields::TeamMembersOnly] = teamdrive->restrictions()->teamMembersOnly();
+        teamDriveMap[Teamdrive::Fields::Restrictions] = restrictionsMap;
     }
 
     if (teamdrive->backgroundImageFile()) {
         QVariantMap backgroundImageFileMap;
-        backgroundImageFileMap[IdAttr] = teamdrive->backgroundImageFile()->id();
-        backgroundImageFileMap[XCoordinateAttr] = teamdrive->backgroundImageFile()->xCoordinate();
-        backgroundImageFileMap[YCoordinateAttr] = teamdrive->backgroundImageFile()->yCoordinate();
-        backgroundImageFileMap[WidthAttr] = teamdrive->backgroundImageFile()->width();
-        teamDriveMap[BackgroundImageFileAttr] = backgroundImageFileMap;
+        backgroundImageFileMap[Teamdrive::BackgroundImageFile::Fields::Id] = teamdrive->backgroundImageFile()->id();
+        backgroundImageFileMap[Teamdrive::BackgroundImageFile::Fields::XCoordinate] = teamdrive->backgroundImageFile()->xCoordinate();
+        backgroundImageFileMap[Teamdrive::BackgroundImageFile::Fields::YCoordinate] = teamdrive->backgroundImageFile()->yCoordinate();
+        backgroundImageFileMap[Teamdrive::BackgroundImageFile::Fields::Width] = teamdrive->backgroundImageFile()->width();
+        teamDriveMap[Teamdrive::Fields::BackgroundImageFile] = backgroundImageFileMap;
     }
 
     if (teamdrive->capabilities()) {
         QVariantMap capabilitiesMap;
-        capabilitiesMap[CanAddChildrenAttr] = teamdrive->capabilities()->canAddChildren();
-        capabilitiesMap[CanChangeCopyRequiresWriterPermissionRestrictionAttr] = teamdrive->capabilities()->canChangeCopyRequiresWriterPermissionRestriction();
-        capabilitiesMap[CanChangeDomainUsersOnlyRestrictionAttr] = teamdrive->capabilities()->canChangeDomainUsersOnlyRestriction();
-        capabilitiesMap[CanChangeTeamDriveBackgroundAttr] = teamdrive->capabilities()->canChangeTeamDriveBackground();
-        capabilitiesMap[CanChangeTeamMembersOnlyRestrictionAttr] = teamdrive->capabilities()->canChangeTeamMembersOnlyRestriction();
-        capabilitiesMap[CanCommentAttr] = teamdrive->capabilities()->canComment();
-        capabilitiesMap[CanCopyAttr] = teamdrive->capabilities()->canCopy();
-        capabilitiesMap[CanDeleteChildrenAttr] = teamdrive->capabilities()->canDeleteChildren();
-        capabilitiesMap[CanDeleteTeamDriveAttr] = teamdrive->capabilities()->canDeleteTeamDrive();
-        capabilitiesMap[CanDownloadAttr] = teamdrive->capabilities()->canDownload();
-        capabilitiesMap[CanEditAttr] = teamdrive->capabilities()->canEdit();
-        capabilitiesMap[CanListChildrenAttr] = teamdrive->capabilities()->canListChildren();
-        capabilitiesMap[CanManageMembersAttr] = teamdrive->capabilities()->canManageMembers();
-        capabilitiesMap[CanReadRevisionsAttr] = teamdrive->capabilities()->canReadRevisions();
-        capabilitiesMap[CanRenameAttr] = teamdrive->capabilities()->canRename();
-        capabilitiesMap[CanRenameTeamDriveAttr] = teamdrive->capabilities()->canRenameTeamDrive();
-        capabilitiesMap[CanShareAttr] = teamdrive->capabilities()->canShare();
-        capabilitiesMap[CanTrashChildrenAttr] = teamdrive->capabilities()->canTrashChildren();
-        teamDriveMap[CapabilitiesAttr] = capabilitiesMap;
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanAddChildren] = teamdrive->capabilities()->canAddChildren();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanChangeCopyRequiresWriterPermissionRestriction] = teamdrive->capabilities()->canChangeCopyRequiresWriterPermissionRestriction();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanChangeDomainUsersOnlyRestriction] = teamdrive->capabilities()->canChangeDomainUsersOnlyRestriction();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanChangeTeamDriveBackground] = teamdrive->capabilities()->canChangeTeamDriveBackground();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanChangeTeamMembersOnlyRestriction] = teamdrive->capabilities()->canChangeTeamMembersOnlyRestriction();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanComment] = teamdrive->capabilities()->canComment();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanCopy] = teamdrive->capabilities()->canCopy();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanDeleteChildren] = teamdrive->capabilities()->canDeleteChildren();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanDeleteTeamDrive] = teamdrive->capabilities()->canDeleteTeamDrive();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanDownload] = teamdrive->capabilities()->canDownload();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanEdit] = teamdrive->capabilities()->canEdit();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanListChildren] = teamdrive->capabilities()->canListChildren();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanManageMembers] = teamdrive->capabilities()->canManageMembers();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanReadRevisions] = teamdrive->capabilities()->canReadRevisions();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanRename] = teamdrive->capabilities()->canRename();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanRenameTeamDrive] = teamdrive->capabilities()->canRenameTeamDrive();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanShare] = teamdrive->capabilities()->canShare();
+        capabilitiesMap[Teamdrive::Capabilities::Fields::CanTrashChildren] = teamdrive->capabilities()->canTrashChildren();
+        teamDriveMap[Teamdrive::Fields::Capabilities] = capabilitiesMap;
     }
 
     QJsonDocument document = QJsonDocument::fromVariant(teamDriveMap);
diff --git a/src/drive/teamdrivefetchjob.h b/src/drive/teamdrivefetchjob.h
--- a/src/drive/teamdrivefetchjob.h
+++ b/src/drive/teamdrivefetchjob.h
@@ -77,6 +77,9 @@
     void setUseDomainAdminAccess(bool useDomainAdminAccess);
     bool useDomainAdminAccess() const;
 
+    void setFields(const QStringList &fields);
+    QStringList fields() const;
+
   protected:
     void start() override;
     KGAPI2::ObjectsList handleReplyWithItems(const QNetworkReply *reply,
diff --git a/src/drive/teamdrivefetchjob.cpp b/src/drive/teamdrivefetchjob.cpp
--- a/src/drive/teamdrivefetchjob.cpp
+++ b/src/drive/teamdrivefetchjob.cpp
@@ -51,6 +51,8 @@
     int maxResults = 0;
     bool useDomainAdminAccess = false;
 
+    QStringList fields;
+
   private:
     TeamdriveFetchJob *const q;
 };
@@ -116,6 +118,21 @@
     return d->useDomainAdminAccess;
 }
 
+void TeamdriveFetchJob::setFields(const QStringList &fields)
+{
+    if (isRunning()) {
+        qCWarning(KGAPIDebug) << "Called setFields() on running job. Ignoring.";
+        return;
+    }
+
+    d->fields = fields;
+}
+
+QStringList TeamdriveFetchJob::fields() const
+{
+    return d->fields;
+}
+
 void TeamdriveFetchJob::start()
 {
     QUrl url;
@@ -124,6 +141,13 @@
         applyRequestParameters(url);
     } else {
         url = DriveService::fetchTeamdriveUrl(d->teamdriveId);
+        if (!d->fields.isEmpty()) {
+            // Deserializing requires kind attribute, always force add it
+            if (!d->fields.contains(Teamdrive::Fields::Kind)) {
+                d->fields << Teamdrive::Fields::Kind;
+            }
+            Job::setFields(d->fields);
+        }
     }
 
     QNetworkRequest request(url);
@@ -177,5 +201,17 @@
     if (!d->searchQuery.isEmpty()) {
         query.addQueryItem(QStringLiteral("q"), d->searchQuery.serialize());
     }
+    if (!d->fields.isEmpty()) {
+        // Deserializing requires kind attribute, always force add it
+        if (!d->fields.contains(Teamdrive::Fields::Kind)) {
+            d->fields << Teamdrive::Fields::Kind;
+        }
+        QString itemFields = QStringLiteral("items(%1)").arg(d->fields.join(QStringLiteral(",")));
+        Job::setFields({
+            Teamdrive::Fields::Kind,
+            Teamdrive::Fields::NextPageToken,
+            itemFields
+        });
+    }
     url.setQuery(query);
 }