diff --git a/go/protocol/keybase1/block.go b/go/protocol/keybase1/block.go
index 268df99ce486..e726c925b71d 100644
--- a/go/protocol/keybase1/block.go
+++ b/go/protocol/keybase1/block.go
@@ -614,74 +614,74 @@ type BlockClient struct {
 }
 
 func (c BlockClient) GetSessionChallenge(ctx context.Context) (res ChallengeInfo, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.block.getSessionChallenge", []interface{}{GetSessionChallengeArg{}}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.getSessionChallenge", []interface{}{GetSessionChallengeArg{}}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c BlockClient) AuthenticateSession(ctx context.Context, signature string) (err error) {
 	__arg := AuthenticateSessionArg{Signature: signature}
-	err = c.Cli.Call(ctx, "keybase.1.block.authenticateSession", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.authenticateSession", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c BlockClient) PutBlock(ctx context.Context, __arg PutBlockArg) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.block.putBlock", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.putBlock", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c BlockClient) PutBlockAgain(ctx context.Context, __arg PutBlockAgainArg) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.block.putBlockAgain", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.putBlockAgain", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c BlockClient) GetBlock(ctx context.Context, __arg GetBlockArg) (res GetBlockRes, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.block.getBlock", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.getBlock", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c BlockClient) GetBlockSizes(ctx context.Context, __arg GetBlockSizesArg) (res GetBlockSizesRes, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.block.getBlockSizes", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.getBlockSizes", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c BlockClient) AddReference(ctx context.Context, __arg AddReferenceArg) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.block.addReference", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.addReference", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c BlockClient) DelReference(ctx context.Context, __arg DelReferenceArg) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.block.delReference", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.delReference", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c BlockClient) ArchiveReference(ctx context.Context, __arg ArchiveReferenceArg) (res []BlockReference, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.block.archiveReference", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.archiveReference", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c BlockClient) DelReferenceWithCount(ctx context.Context, __arg DelReferenceWithCountArg) (res DowngradeReferenceRes, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.block.delReferenceWithCount", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.delReferenceWithCount", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c BlockClient) ArchiveReferenceWithCount(ctx context.Context, __arg ArchiveReferenceWithCountArg) (res DowngradeReferenceRes, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.block.archiveReferenceWithCount", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.archiveReferenceWithCount", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c BlockClient) GetReferenceCount(ctx context.Context, __arg GetReferenceCountArg) (res ReferenceCountRes, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.block.getReferenceCount", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.getReferenceCount", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c BlockClient) GetUserQuotaInfo(ctx context.Context) (res []byte, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.block.getUserQuotaInfo", []interface{}{GetUserQuotaInfoArg{}}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.getUserQuotaInfo", []interface{}{GetUserQuotaInfoArg{}}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c BlockClient) GetTeamQuotaInfo(ctx context.Context, tid TeamID) (res []byte, err error) {
 	__arg := GetTeamQuotaInfoArg{Tid: tid}
-	err = c.Cli.Call(ctx, "keybase.1.block.getTeamQuotaInfo", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.getTeamQuotaInfo", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
@@ -697,6 +697,6 @@ func (c BlockClient) GetTeamQuotaInfo2(ctx context.Context, __arg GetTeamQuotaIn
 }
 
 func (c BlockClient) BlockPing(ctx context.Context) (res BlockPingResponse, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.block.blockPing", []interface{}{BlockPingArg{}}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.block.blockPing", []interface{}{BlockPingArg{}}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
diff --git a/go/protocol/keybase1/metadata.go b/go/protocol/keybase1/metadata.go
index f741c63dc8c4..e1affaf662de 100644
--- a/go/protocol/keybase1/metadata.go
+++ b/go/protocol/keybase1/metadata.go
@@ -764,150 +764,150 @@ type MetadataClient struct {
 }
 
 func (c MetadataClient) GetChallenge(ctx context.Context) (res ChallengeInfo, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.getChallenge", []interface{}{GetChallengeArg{}}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.getChallenge", []interface{}{GetChallengeArg{}}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) Authenticate(ctx context.Context, signature string) (res int, err error) {
 	__arg := AuthenticateArg{Signature: signature}
-	err = c.Cli.Call(ctx, "keybase.1.metadata.authenticate", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.authenticate", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) PutMetadata(ctx context.Context, __arg PutMetadataArg) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.putMetadata", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.putMetadata", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) GetMetadata(ctx context.Context, __arg GetMetadataArg) (res MetadataResponse, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.getMetadata", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.getMetadata", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) GetMetadataByTimestamp(ctx context.Context, __arg GetMetadataByTimestampArg) (res MDBlock, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.getMetadataByTimestamp", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.getMetadataByTimestamp", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) RegisterForUpdates(ctx context.Context, __arg RegisterForUpdatesArg) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.registerForUpdates", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.registerForUpdates", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) PruneBranch(ctx context.Context, __arg PruneBranchArg) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.pruneBranch", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.pruneBranch", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) PutKeys(ctx context.Context, __arg PutKeysArg) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.putKeys", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.putKeys", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) GetKey(ctx context.Context, __arg GetKeyArg) (res []byte, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.getKey", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.getKey", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) DeleteKey(ctx context.Context, __arg DeleteKeyArg) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.deleteKey", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.deleteKey", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) TruncateLock(ctx context.Context, folderID string) (res bool, err error) {
 	__arg := TruncateLockArg{FolderID: folderID}
-	err = c.Cli.Call(ctx, "keybase.1.metadata.truncateLock", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.truncateLock", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) TruncateUnlock(ctx context.Context, folderID string) (res bool, err error) {
 	__arg := TruncateUnlockArg{FolderID: folderID}
-	err = c.Cli.Call(ctx, "keybase.1.metadata.truncateUnlock", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.truncateUnlock", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) GetFolderHandle(ctx context.Context, __arg GetFolderHandleArg) (res []byte, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.getFolderHandle", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.getFolderHandle", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) GetFoldersForRekey(ctx context.Context, deviceKID KID) (err error) {
 	__arg := GetFoldersForRekeyArg{DeviceKID: deviceKID}
-	err = c.Cli.Call(ctx, "keybase.1.metadata.getFoldersForRekey", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.getFoldersForRekey", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) Ping(ctx context.Context) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.ping", []interface{}{PingArg{}}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.ping", []interface{}{PingArg{}}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) Ping2(ctx context.Context) (res PingResponse, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.ping2", []interface{}{Ping2Arg{}}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.ping2", []interface{}{Ping2Arg{}}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) GetLatestFolderHandle(ctx context.Context, folderID string) (res []byte, err error) {
 	__arg := GetLatestFolderHandleArg{FolderID: folderID}
-	err = c.Cli.Call(ctx, "keybase.1.metadata.getLatestFolderHandle", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.getLatestFolderHandle", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) GetKeyBundles(ctx context.Context, __arg GetKeyBundlesArg) (res KeyBundleResponse, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.getKeyBundles", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.getKeyBundles", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) Lock(ctx context.Context, __arg LockArg) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.lock", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.lock", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) ReleaseLock(ctx context.Context, __arg ReleaseLockArg) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.releaseLock", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.releaseLock", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) StartImplicitTeamMigration(ctx context.Context, folderID string) (err error) {
 	__arg := StartImplicitTeamMigrationArg{FolderID: folderID}
-	err = c.Cli.Call(ctx, "keybase.1.metadata.startImplicitTeamMigration", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.startImplicitTeamMigration", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) GetMerkleRoot(ctx context.Context, __arg GetMerkleRootArg) (res MerkleRoot, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.getMerkleRoot", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.getMerkleRoot", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) GetMerkleRootLatest(ctx context.Context, treeID MerkleTreeID) (res MerkleRoot, err error) {
 	__arg := GetMerkleRootLatestArg{TreeID: treeID}
-	err = c.Cli.Call(ctx, "keybase.1.metadata.getMerkleRootLatest", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.getMerkleRootLatest", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) GetMerkleRootSince(ctx context.Context, __arg GetMerkleRootSinceArg) (res MerkleRoot, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.getMerkleRootSince", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.getMerkleRootSince", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) GetMerkleNode(ctx context.Context, hash string) (res []byte, err error) {
 	__arg := GetMerkleNodeArg{Hash: hash}
-	err = c.Cli.Call(ctx, "keybase.1.metadata.getMerkleNode", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.getMerkleNode", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) FindNextMD(ctx context.Context, __arg FindNextMDArg) (res FindNextMDResponse, err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.findNextMD", []interface{}{__arg}, &res, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.findNextMD", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) SetImplicitTeamModeForTest(ctx context.Context, implicitTeamMode string) (err error) {
 	__arg := SetImplicitTeamModeForTestArg{ImplicitTeamMode: implicitTeamMode}
-	err = c.Cli.Call(ctx, "keybase.1.metadata.setImplicitTeamModeForTest", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.setImplicitTeamModeForTest", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataClient) ForceMerkleBuildForTest(ctx context.Context) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadata.forceMerkleBuildForTest", []interface{}{ForceMerkleBuildForTestArg{}}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadata.forceMerkleBuildForTest", []interface{}{ForceMerkleBuildForTestArg{}}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
diff --git a/go/protocol/keybase1/metadata_update.go b/go/protocol/keybase1/metadata_update.go
index c05fa91befd4..a9f064ea31ad 100644
--- a/go/protocol/keybase1/metadata_update.go
+++ b/go/protocol/keybase1/metadata_update.go
@@ -99,17 +99,17 @@ type MetadataUpdateClient struct {
 }
 
 func (c MetadataUpdateClient) MetadataUpdate(ctx context.Context, __arg MetadataUpdateArg) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadataUpdate.metadataUpdate", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadataUpdate.metadataUpdate", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataUpdateClient) FolderNeedsRekey(ctx context.Context, __arg FolderNeedsRekeyArg) (err error) {
-	err = c.Cli.Call(ctx, "keybase.1.metadataUpdate.folderNeedsRekey", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadataUpdate.folderNeedsRekey", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
 
 func (c MetadataUpdateClient) FoldersNeedRekey(ctx context.Context, requests []RekeyRequest) (err error) {
 	__arg := FoldersNeedRekeyArg{Requests: requests}
-	err = c.Cli.Call(ctx, "keybase.1.metadataUpdate.foldersNeedRekey", []interface{}{__arg}, nil, 0*time.Millisecond)
+	err = c.Cli.CallCompressed(ctx, "keybase.1.metadataUpdate.foldersNeedRekey", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
 	return
 }
diff --git a/protocol/avdl/keybase1/block.avdl b/protocol/avdl/keybase1/block.avdl
index 9db59c006bbe..75d0f399aed6 100644
--- a/protocol/avdl/keybase1/block.avdl
+++ b/protocol/avdl/keybase1/block.avdl
@@ -1,4 +1,5 @@
 @namespace("keybase.1")
+@compression_type("gzip")
 
 protocol block {
   import idl "backend_common.avdl";
@@ -103,10 +104,8 @@ protocol block {
     int64 gitLimit;
   }
 
-  @compression_type("gzip")
   BlockQuotaInfo getUserQuotaInfo2(boolean includeFolders);
 
-  @compression_type("gzip")
   BlockQuotaInfo getTeamQuotaInfo2(TeamID tid, boolean includeFolders);
 
   BlockPingResponse blockPing();
diff --git a/protocol/avdl/keybase1/metadata.avdl b/protocol/avdl/keybase1/metadata.avdl
index 6b7686d74c6c..402983f59116 100644
--- a/protocol/avdl/keybase1/metadata.avdl
+++ b/protocol/avdl/keybase1/metadata.avdl
@@ -1,4 +1,5 @@
 @namespace("keybase.1")
+@compression_type("gzip")
 
 protocol metadata {
   import idl "backend_common.avdl";
diff --git a/protocol/avdl/keybase1/metadata_update.avdl b/protocol/avdl/keybase1/metadata_update.avdl
index f6d440813f91..3421f2b1a263 100644
--- a/protocol/avdl/keybase1/metadata_update.avdl
+++ b/protocol/avdl/keybase1/metadata_update.avdl
@@ -1,4 +1,5 @@
 @namespace("keybase.1")
+@compression_type("gzip")
 
 protocol metadataUpdate {
   import idl "backend_common.avdl";
diff --git a/protocol/json/keybase1/block.json b/protocol/json/keybase1/block.json
index 4bc94856a878..93575d3585a9 100644
--- a/protocol/json/keybase1/block.json
+++ b/protocol/json/keybase1/block.json
@@ -439,8 +439,7 @@
           "type": "boolean"
         }
       ],
-      "response": "BlockQuotaInfo",
-      "compression_type": "gzip"
+      "response": "BlockQuotaInfo"
     },
     "getTeamQuotaInfo2": {
       "request": [
@@ -453,13 +452,13 @@
           "type": "boolean"
         }
       ],
-      "response": "BlockQuotaInfo",
-      "compression_type": "gzip"
+      "response": "BlockQuotaInfo"
     },
     "blockPing": {
       "request": [],
       "response": "BlockPingResponse"
     }
   },
-  "namespace": "keybase.1"
+  "namespace": "keybase.1",
+  "compression_type": "gzip"
 }
\ No newline at end of file
diff --git a/protocol/json/keybase1/metadata.json b/protocol/json/keybase1/metadata.json
index ba184b612eae..35a3ac781212 100644
--- a/protocol/json/keybase1/metadata.json
+++ b/protocol/json/keybase1/metadata.json
@@ -558,5 +558,6 @@
       "response": null
     }
   },
-  "namespace": "keybase.1"
+  "namespace": "keybase.1",
+  "compression_type": "gzip"
 }
\ No newline at end of file
diff --git a/protocol/json/keybase1/metadata_update.json b/protocol/json/keybase1/metadata_update.json
index 5861a0e276e6..88b68ca99c32 100644
--- a/protocol/json/keybase1/metadata_update.json
+++ b/protocol/json/keybase1/metadata_update.json
@@ -62,5 +62,6 @@
       "response": null
     }
   },
-  "namespace": "keybase.1"
+  "namespace": "keybase.1",
+  "compression_type": "gzip"
 }
\ No newline at end of file