Protocol Buffers Well-Known Types

API documentation for the google.protobuf package.



Any contains an arbitrary serialized message along with a URL that describes the type of the serialized message.


The JSON representation of an Any value uses the regular representation of the deserialized, embedded message, with an additional field @type which contains the type URL. Example:

package google.profile;
message Person {
  string first_name = 1;
  string last_name = 2;
  "@type": "",
  "firstName": <string>,
  "lastName": <string>

If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field value which holds the custom JSON in addition to the @type field. Example (for message google.protobuf.Duration):

  "@type": "",
  "value": "1.212s"
Field nameTypeDescription

A URL/resource name whose content describes the type of the serialized message.

For URLs which use the schema http, https, or no schema, the following restrictions and interpretations apply:

  • If no schema is provided, https is assumed.
  • The last segment of the URL's path must represent the fully qualified name of the type (as in path/google.protobuf.Duration).
  • An HTTP GET on the URL must yield a google.protobuf.Type value in binary format, or produce an error.
  • Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)

Schemas other than http, https (or the empty schema) might be used with implementation specific semantics.

valuebytesMust be valid serialized data of the above specified type.


Api is a light-weight descriptor for a protocol buffer service.

Field nameTypeDescription
namestringThe fully qualified name of this api, including package name followed by the api's simple name.
methodsMethodThe methods of this api, in unspecified order.
optionsOptionAny metadata attached to the API.

A version string for this api. If specified, must have the form major-version.minor-version, as in 1.10. If the minor version is omitted, it defaults to zero. If the entire version field is empty, the major version is derived from the package name, as outlined below. If the field is not empty, the version in the package name will be verified to be consistent with what is provided here.

The versioning schema uses semantic versioning where the major version number indicates a breaking change and the minor version an additive, non-breaking change. Both version numbers are signals to users what to expect from different versions, and should be carefully chosen based on the product plan.

The major version is also reflected in the package name of the API, which must end in v<major-version>, as in google.feature.v1. For major versions 0 and 1, the suffix can be omitted. Zero major versions must only be used for experimental, none-GA apis.

source_contextSourceContextSource context for the protocol buffer service represented by this message.
mixinsMixinIncluded APIs. See Mixin.
syntaxSyntaxThe source syntax of the service.


Wrapper message for bool.

The JSON representation for BoolValue is JSON true and false.

Field nameTypeDescription
valueboolThe bool value.


Wrapper message for bytes.

The JSON representation for BytesValue is JSON string.

Field nameTypeDescription
valuebytesThe bytes value.


Wrapper message for double.

The JSON representation for DoubleValue is JSON number.

Field nameTypeDescription
valuedoubleThe double value.


A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years.

Example 1: Compute Duration from two Timestamps in pseudo code.

Timestamp start = ...;
Timestamp end = ...;
Duration duration = ...;

duration.seconds = end.seconds - start.seconds;
duration.nanos = end.nanos - start.nanos;

if (duration.seconds < 0 && duration.nanos > 0) {
  duration.seconds += 1;
  duration.nanos -= 1000000000;
} else if (duration.seconds > 0 && duration.nanos < 0) {
  duration.seconds -= 1;
  duration.nanos += 1000000000;

Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.

Timestamp start = ...;
Duration duration = ...;
Timestamp end = ...;

end.seconds = start.seconds + duration.seconds;
end.nanos = start.nanos + duration.nanos;

if (end.nanos < 0) {
  end.seconds -= 1;
  end.nanos += 1000000000;
} else if (end.nanos >= 1000000000) {
  end.seconds += 1;
  end.nanos -= 1000000000;

The JSON representation for Duration is a String that ends in s to indicate seconds and is preceded by the number of seconds, with nanoseconds expressed as fractional seconds.

Field nameTypeDescription
secondsint64Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive.
nanosint32Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 seconds field and a positive or negative nanos field. For durations of one second or more, a non-zero value for the nanos field must be of the same sign as the seconds field. Must be from -999,999,999 to +999,999,999 inclusive.


A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance:

service Foo {
  rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);

The JSON representation for Empty is empty JSON object {}.


Enum type definition

Field nameTypeDescription
namestringEnum type name.
enumvalueEnumValueEnum value definitions.
optionsOptionProtocol buffer options.
source_contextSourceContextThe source context.
syntaxSyntaxThe source syntax.


Enum value definition.

Field nameTypeDescription
namestringEnum value name.
numberint32Enum value number.
optionsOptionProtocol buffer options.


A single field of a message type.

Field nameTypeDescription
kindKindThe field type.
cardinalityCardinalityThe field cardinality.
numberint32The field number.
namestringThe field name.
type_urlstringThe field type URL, without the scheme, for message or enumeration types. Example: "".
oneof_indexint32The index of the field type in Type.oneofs, for message or enumeration types. The first type has index 1; zero means the type is not in the list.
packedboolWhether to use alternative packed wire representation.
optionsOptionThe protocol buffer options.
json_namestringThe field JSON name.
default_valuestringThe string value of the default value of this field. Proto2 syntax only.


Whether a field is optional, required, or repeated.

Enum valueDescription
CARDINALITY_UNKNOWNFor fields with unknown cardinality.
CARDINALITY_OPTIONALFor optional fields.
CARDINALITY_REQUIREDFor required fields. Proto2 syntax only.
CARDINALITY_REPEATEDFor repeated fields.


Basic field types.

Enum valueDescription
TYPE_UNKNOWNField type unknown.
TYPE_DOUBLEField type double.
TYPE_FLOATField type float.
TYPE_INT64Field type int64.
TYPE_UINT64Field type uint64.
TYPE_INT32Field type int32.
TYPE_FIXED64Field type fixed64.
TYPE_FIXED32Field type fixed32.
TYPE_BOOLField type bool.
TYPE_STRINGField type string.
TYPE_GROUPField type group. Proto2 syntax only, and deprecated.
TYPE_MESSAGEField type message.
TYPE_BYTESField type bytes.
TYPE_UINT32Field type uint32.
TYPE_ENUMField type enum.
TYPE_SFIXED32Field type sfixed32.
TYPE_SFIXED64Field type sfixed64.
TYPE_SINT32Field type sint32.
TYPE_SINT64Field type sint64.


FieldMask represents a set of symbolic field paths, for example:

paths: "f.a"
paths: "f.b.d"

Here f represents a field in some root message, a and b fields in the message found in f, and d a field found in the message in f.b.

Field masks are used to specify a subset of fields that should be returned by a get operation (a projection), or modified by an update operation. Field masks also have a custom JSON encoding (see below).

Field Masks in Projections

When a FieldMask specifies a projection, the API will filter the response message (or sub-message) to contain only those fields specified in the mask. For example, consider this "pre-masking" response message:

f {
  a : 22
  b {
    d : 1
    x : 2
  y : 13
z: 8

After applying the mask in the previous example, the API response will not contain specific values for fields x, y, or z (their value will be set to the default, and omitted in proto text output):

f {
  a : 22
  b {
    d : 1

A repeated field is not allowed except at the last position of a field mask.

If a FieldMask object is not present in a get operation, the operation applies to all fields (as if a FieldMask of all fields had been specified).

Note that a field mask does not necessarily apply to the top-level response message. In case of a REST get operation, the field mask applies directly to the response, but in case of a REST list operation, the mask instead applies to each individual message in the returned resource list. In case of a REST custom method, other definitions may be used. Where the mask applies will be clearly documented together with its declaration in the API. In any case, the effect on the returned resource/resources is required behavior for APIs.

Field Masks in Update Operations

A field mask in update operations specifies which fields of the targeted resource are going to be updated. The API is required to only change the values of the fields as specified in the mask and leave the others untouched. If a resource is passed in to describe the updated values, the API ignores the values of all fields not covered by the mask.

In order to reset a field’s value to the default, the field must be in the mask and set to the default value in the provided resource. Hence, in order to reset all fields of a resource, provide a default instance of the resource and set all fields in the mask, or do not provide a mask as described below.

If a field mask is not present on update, the operation applies to all fields (as if a field mask of all fields has been specified). Note that in the presence of schema evolution, this may mean that fields the client does not know and has therefore not filled into the request will be reset to their default. If this is unwanted behavior, a specific service may require a client to always specify a field mask, producing an error if not.

As with get operations, the location of the resource which describes the updated values in the request message depends on the operation kind. In any case, the effect of the field mask is required to be honored by the API.

Considerations for HTTP REST

The HTTP kind of an update operation which uses a field mask must be set to PATCH instead of PUT in order to satisfy HTTP semantics (PUT must only be used for full updates).

JSON Encoding of Field Masks

In JSON, a field mask is encoded as a single string where paths are separated by a comma. Fields name in each path are converted to/from lower-camel naming conventions.

As an example, consider the following message declarations:

message Profile {
  User user = 1;
  Photo photo = 2;
message User {
  string display_name = 1;
  string address = 2;

In proto a field mask for Profile may look as such:

mask {
  paths: "user.display_name"
  paths: "photo"

In JSON, the same mask is represented as below:

  mask: "user.displayName,photo"
Field nameTypeDescription
pathsstringThe set of field mask paths.


Wrapper message for float.

The JSON representation for FloatValue is JSON number.

Field nameTypeDescription
valuefloatThe float value.


Wrapper message for int32.

The JSON representation for Int32Value is JSON number.

Field nameTypeDescription
valueint32The int32 value.


Wrapper message for int64.

The JSON representation for Int64Value is JSON string.

Field nameTypeDescription
valueint64The int64 value.


ListValue is a wrapper around a repeated field of values.

The JSON representation for ListValue is JSON array.

Field nameTypeDescription
valuesValueRepeated field of dynamically typed values.


Method represents a method of an api.

Field nameTypeDescription
namestringThe simple name of this method.
request_type_urlstringA URL of the input message type.
request_streamingboolIf true, the request is streamed.
response_type_urlstringThe URL of the output message type.
response_streamingboolIf true, the response is streamed.
optionsOptionAny metadata attached to the method.
syntaxSyntaxThe source syntax of this method.


Declares an API to be included in this API. The including API must redeclare all the methods from the included API, but documentation and options are inherited as follows:

  • If after comment and whitespace stripping, the documentation string of the redeclared method is empty, it will be inherited from the original method.

  • Each annotation belonging to the service config (http, visibility) which is not set in the redeclared method will be inherited.

  • If an http annotation is inherited, the path pattern will be modified as follows. Any version prefix will be replaced by the version of the including API plus the root path if specified.

Example of a simple mixin:

package google.acl.v1;
service AccessControl {
  // Get the underlying ACL object.
  rpc GetAcl(GetAclRequest) returns (Acl) {
    option (google.api.http).get = "/v1/{resource=**}:getAcl";

service Storage {
  //       rpc GetAcl(GetAclRequest) returns (Acl);

  // Get a data record.
  rpc GetData(GetDataRequest) returns (Data) {
    option (google.api.http).get = "/v2/{resource=**}";

Example of a mixin configuration:

- name:
  - name: google.acl.v1.AccessControl

The mixin construct implies that all methods in AccessControl are also declared with same name and request/response types in Storage. A documentation generator or annotation processor will see the effective Storage.GetAcl method after inheriting documentation and annotations as follows:

service Storage {
  // Get the underlying ACL object.
  rpc GetAcl(GetAclRequest) returns (Acl) {
    option (google.api.http).get = "/v2/{resource=**}:getAcl";

Note how the version in the path pattern changed from v1 to v2.

If the root field in the mixin is specified, it should be a relative path under which inherited HTTP paths are placed. Example:

- name:
  - name: google.acl.v1.AccessControl
    root: acls

This implies the following inherited HTTP annotation:

service Storage {
  // Get the underlying ACL object.
  rpc GetAcl(GetAclRequest) returns (Acl) {
    option (google.api.http).get = "/v2/acls/{resource=**}:getAcl";
Field nameTypeDescription
namestringThe fully qualified name of the API which is included.
rootstringIf non-empty specifies a path under which inherited HTTP paths are rooted.


NullValue is a singleton enumeration to represent the null value for the Value type union.

The JSON representation for NullValue is JSON null.

Enum valueDescription
NULL_VALUENull value.


A protocol buffer option, which can be attached to a message, field, enumeration, etc.

Field nameTypeDescription
namestringThe option's name. For example, "java_package".
valueAnyThe option's value. For example, "".


SourceContext represents information about the source of a protobuf element, like the file in which it is defined.

Field nameTypeDescription
file_namestringThe path-qualified name of the .proto file that contained the associated protobuf element. For example: "google/protobuf/source.proto".


Wrapper message for string.

The JSON representation for StringValue is JSON string.

Field nameTypeDescription
valuestringThe string value.


Struct represents a structured data value, consisting of fields which map to dynamically typed values. In some languages, Struct might be supported by a native representation. For example, in scripting languages like JS a struct is represented as an object. The details of that representation are described together with the proto support for the language.

The JSON representation for Struct is JSON object.

Field nameTypeDescription
fieldsmap<string, Value>Map of dynamically typed values.


The syntax in which a protocol buffer element is defined.

Enum valueDescription
SYNTAX_PROTO2Syntax proto2.
SYNTAX_PROTO3Syntax proto3.


A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings. See

Example 1: Compute Timestamp from POSIX time().

Timestamp timestamp;

Example 2: Compute Timestamp from POSIX gettimeofday().

struct timeval tv;
gettimeofday(&tv, NULL);

Timestamp timestamp;
timestamp.set_nanos(tv.tv_usec * 1000);

Example 3: Compute Timestamp from Win32 GetSystemTimeAsFileTime().

UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

// A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
// is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
Timestamp timestamp;
timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

Example 4: Compute Timestamp from Java System.currentTimeMillis().

long millis = System.currentTimeMillis();

Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
    .setNanos((int) ((millis % 1000) * 1000000)).build();

Example 5: Compute Timestamp from current time in Python.

now = time.time()
seconds = int(now)
nanos = int((now - seconds) * 10**9)
timestamp = Timestamp(seconds=seconds, nanos=nanos)
Field nameTypeDescription
secondsint64Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
nanosint32Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.


A protocol buffer message type.

Field nameTypeDescription
namestringThe fully qualified message name.
fieldsFieldThe list of fields.
oneofsstringThe list of types appearing in oneof definitions in this type.
optionsOptionThe protocol buffer options.
source_contextSourceContextThe source context.
syntaxSyntaxThe source syntax.


Wrapper message for uint32.

The JSON representation for UInt32Value is JSON number.

Field nameTypeDescription
valueuint32The uint32 value.


Wrapper message for uint64.

The JSON representation for UInt64Value is JSON string.

Field nameTypeDescription
valueuint64The uint64 value.


Value represents a dynamically typed value which can be either null, a number, a string, a boolean, a recursive struct value, or a list of values. A producer of value is expected to set one of that variants, absence of any variant indicates an error.

The JSON representation for Value is JSON value.

Field nameTypeDescription
Union field, only one of the following:
null_valueNullValueRepresents a null value.
number_valuedoubleRepresents a double value. Note that attempting to serialize NaN or Infinity results in error. (We can't serialize these as string "NaN" or "Infinity" values like we do for regular fields, because they would parse as string_value, not number_value).
string_valuestringRepresents a string value.
bool_valueboolRepresents a boolean value.
struct_valueStructRepresents a structured value.
list_valueListValueRepresents a repeated Value.