JobQuery

Input only.

The query required to perform a search query.

JSON representation
{
  "query": string,
  "queryLanguageCode": string,
  "companyNames": [
    string
  ],
  "locationFilters": [
    {
      object (LocationFilter)
    }
  ],
  "jobCategories": [
    enum (JobCategory)
  ],
  "commuteFilter": {
    object (CommuteFilter)
  },
  "companyDisplayNames": [
    string
  ],
  "compensationFilter": {
    object (CompensationFilter)
  },
  "customAttributeFilter": string,
  "disableSpellCheck": boolean,
  "employmentTypes": [
    enum (EmploymentType)
  ],
  "languageCodes": [
    string
  ],
  "publishTimeRange": {
    object (TimestampRange)
  }
}
Fields
query

string

Optional. The query string that matches against the job title, description, and location fields.

The maximum number of allowed characters is 255.

queryLanguageCode

string

The language code of query. For example, "en-US". This field helps to better interpret the query.

If a value isn't specified, the query language code is automatically detected, which may not be accurate.

Language code should be in BCP-47 format, such as "en-US" or "sr-Latn". For more information, see Tags for Identifying Languages.

companyNames[]

string

Optional. This filter specifies the company entities to search against.

If a value isn't specified, jobs are searched for against all companies.

If multiple values are specified, jobs are searched against the companies specified.

The format is "projects/{project_id}/companies/{company_id}", for example, "projects/api-test-project/companies/foo".

At most 20 company filters are allowed.

locationFilters[]

object (LocationFilter)

Optional. The location filter specifies geo-regions containing the jobs to search against. See LocationFilter for more information.

If a location value isn't specified, jobs fitting the other search criteria are retrieved regardless of where they're located.

If multiple values are specified, jobs are retrieved from any of the specified locations. If different values are specified for the LocationFilter.distance_in_miles parameter, the maximum provided distance is used for all locations.

At most 5 location filters are allowed.

jobCategories[]

enum (JobCategory)

Optional. The category filter specifies the categories of jobs to search against. See [Category][] for more information.

If a value is not specified, jobs from any category are searched against.

If multiple values are specified, jobs from any of the specified categories are searched against.

commuteFilter

object (CommuteFilter)

Optional. Allows filtering jobs by commute time with different travel methods (for example, driving or public transit). Note: This only works with [COMMUTE MODE][Mode#COMMUTE]. When specified, [JobQuery.location_filters] is ignored.

Currently we don't support sorting by commute time.

companyDisplayNames[]

string

Optional. This filter specifies the exact [company display name][Company.display_name] of the jobs to search against.

If a value isn't specified, jobs within the search results are associated with any company.

If multiple values are specified, jobs within the search results may be associated with any of the specified companies.

At most 20 company display name filters are allowed.

compensationFilter

object (CompensationFilter)

Optional. This search filter is applied only to Job.compensation_info. For example, if the filter is specified as "Hourly job with per-hour compensation > $15", only jobs meeting these criteria are searched. If a filter isn't defined, all open jobs are searched.

customAttributeFilter

string

Optional. This filter specifies a structured syntax to match against the Job.custom_attributes marked as filterable.

The syntax for this expression is a subset of SQL syntax.

Supported operators are: =, !=, <, <=, >, and >= where the left of the operator is a custom field key and the right of the operator is a number or a quoted string. You must escape backslash (\) and quote (") characters.

Supported functions are LOWER([field_name]) to perform a case insensitive match and EMPTY([field_name]) to filter on the existence of a key.

Boolean expressions (AND/OR/NOT) are supported up to 3 levels of nesting (for example, "((A AND B AND C) OR NOT D) AND E"), a maximum of 100 comparisons or functions are allowed in the expression. The expression must be < 6000 bytes in length.

Sample Query: (LOWER(driving_license)="class \"a\"" OR EMPTY(driving_license)) AND driving_years > 10

disableSpellCheck

boolean

Optional. This flag controls the spell-check feature. If false, the service attempts to correct a misspelled query, for example, "enginee" is corrected to "engineer".

Defaults to false: a spell check is performed.

employmentTypes[]

enum (EmploymentType)

Optional. The employment type filter specifies the employment type of jobs to search against, such as EmploymentType.FULL_TIME.

If a value is not specified, jobs in the search results includes any employment type.

If multiple values are specified, jobs in the search results include any of the specified employment types.

languageCodes[]

string

Optional. This filter specifies the locale of jobs to search against, for example, "en-US".

If a value isn't specified, the search results can contain jobs in any locale.

Language codes should be in BCP-47 format, such as "en-US" or "sr-Latn". For more information, see Tags for Identifying Languages.

At most 10 language code filters are allowed.

publishTimeRange

object (TimestampRange)

Optional. Jobs published within a range specified by this filter are searched against.

LocationFilter

Input only.

Geographic region of the search.

JSON representation
{
  "address": string,
  "regionCode": string,
  "latLng": {
    object (LatLng)
  },
  "distanceInMiles": number,
  "telecommutePreference": enum (TelecommutePreference)
}
Fields
address

string

Optional. The address name, such as "Mountain View" or "Bay Area".

regionCode

string

Optional. CLDR region code of the country/region of the address. This is used to address ambiguity of the user-input location, for example, "Liverpool" against "Liverpool, NY, US" or "Liverpool, UK".

Set this field if all the jobs to search against are from a same region, or jobs are world-wide, but the job seeker is from a specific region.

See http://cldr.unicode.org/ and http://www.unicode.org/cldr/charts/30/supplemental/territory_information.html for details. Example: "CH" for Switzerland.

latLng

object (LatLng)

Optional. The latitude and longitude of the geographic center from which to search. This field's ignored if address is provided.

distanceInMiles

number

Optional. The distanceInMiles is applied when the location being searched for is identified as a city or smaller. When the location being searched for is a state or larger, this field is ignored.

telecommutePreference

enum (TelecommutePreference)

Optional. Allows the client to return jobs without a set location, specifically, telecommuting jobs (telecommuting is considered by the service as a special location. Job.posting_region indicates if a job permits telecommuting. If this field is set to TelecommutePreference.TELECOMMUTE_ALLOWED, telecommuting jobs are searched, and address and latLng are ignored. If not set or set to TelecommutePreference.TELECOMMUTE_EXCLUDED, telecommute job are not searched.

This filter can be used by itself to search exclusively for telecommuting jobs, or it can be combined with another location filter to search for a combination of job locations, such as "Mountain View" or "telecommuting" jobs. However, when used in combination with other location filters, telecommuting jobs can be treated as less relevant than other jobs in the search response.

TelecommutePreference

Specify whether including telecommute jobs.

Enums
TELECOMMUTE_PREFERENCE_UNSPECIFIED Default value if the telecommute preference is not specified.
TELECOMMUTE_EXCLUDED Exclude telecommute jobs.
TELECOMMUTE_ALLOWED Allow telecommute jobs.

CommuteFilter

Input only.

Parameters needed for commute search.

JSON representation
{
  "commuteMethod": enum (CommuteMethod),
  "startCoordinates": {
    object (LatLng)
  },
  "travelDuration": string,
  "allowImpreciseAddresses": boolean,

  // Union field traffic_option can be only one of the following:
  "roadTraffic": enum (RoadTraffic),
  "departureTime": {
    object (TimeOfDay)
  }
  // End of list of possible types for union field traffic_option.
}
Fields
commuteMethod

enum (CommuteMethod)

Required. The method of transportation for which to calculate the commute time.

startCoordinates

object (LatLng)

Required. The latitude and longitude of the location from which to calculate the commute time.

travelDuration

string (Duration format)

Required. The maximum travel time in seconds. The maximum allowed value is 3600s (one hour). Format is 123s.

A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".

allowImpreciseAddresses

boolean

Optional. If true, jobs without "precise" addresses (street level addresses or GPS coordinates) might also be returned. For city and coarser level addresses, text matching is used. If this field is set to false or is not specified, only jobs that include precise addresses are returned by Commute Search.

Note: If allowImpreciseAddresses is set to true, Commute Search is not able to calculate accurate commute times to jobs with city level and coarser address information. Jobs with imprecise addresses will return a travelDuration time of 0 regardless of distance from the job seeker.

Union field traffic_option. Optional.

Traffic factor to take into account while searching by commute. traffic_option can be only one of the following:

roadTraffic

enum (RoadTraffic)

Optional. Specifies the traffic density to use when calculating commute time.

departureTime

object (TimeOfDay)

Optional. The departure time used to calculate traffic impact, represented as google.type.TimeOfDay in local time zone.

Currently traffic model is restricted to hour level resolution.

CommuteMethod

Method for commute.

Enums
COMMUTE_METHOD_UNSPECIFIED Commute method is not specified.
DRIVING Commute time is calculated based on driving time.
TRANSIT Commute time is calculated based on public transit including bus, metro, subway, etc.

RoadTraffic

The traffic density to use when calculating commute time.

Enums
ROAD_TRAFFIC_UNSPECIFIED Road traffic situation is not specified.
TRAFFIC_FREE Optimal commute time without considering any traffic impact.
BUSY_HOUR Commute time calculation takes in account the peak traffic impact.

CompensationFilter

Input only.

Filter on job compensation type and amount.

JSON representation
{
  "type": enum (FilterType),
  "units": [
    enum (CompensationUnit)
  ],
  "range": {
    object (CompensationRange)
  },
  "includeJobsWithUnspecifiedCompensationRange": boolean
}
Fields
type

enum (FilterType)

Required. Type of filter.

units[]

enum (CompensationUnit)

Required. Specify desired base compensation entry's CompensationInfo.CompensationUnit.

range

object (CompensationRange)

Optional. Compensation range.

includeJobsWithUnspecifiedCompensationRange

boolean

Optional. If set to true, jobs with unspecified compensation range fields are included.

FilterType

Specify the type of filtering.

Enums
FILTER_TYPE_UNSPECIFIED Filter type unspecified. Position holder, INVALID, should never be used.
UNIT_ONLY

Filter by base compensation entry's unit. A job is a match if and only if the job contains a base CompensationEntry and the base CompensationEntry's unit matches provided units. Populate one or more units.

See CompensationInfo.CompensationEntry for definition of base compensation entry.

UNIT_AND_AMOUNT

Filter by base compensation entry's unit and amount / range. A job is a match if and only if the job contains a base CompensationEntry, and the base entry's unit matches provided [compensationUnits][] and amount or range overlaps with provided [compensationRange][].

See CompensationInfo.CompensationEntry for definition of base compensation entry.

Set exactly one units and populate range.

ANNUALIZED_BASE_AMOUNT

Filter by annualized base compensation amount and base compensation entry's unit. Populate range and zero or more units.

ANNUALIZED_TOTAL_AMOUNT

Filter by annualized total compensation amount and base compensation entry's unit . Populate range and zero or more units.

TimestampRange

Message representing a period of time between two timestamps.

JSON representation
{
  "startTime": string,
  "endTime": string
}
Fields
startTime

string (Timestamp format)

Begin of the period.

A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds. Example: "2014-10-02T15:01:23.045123456Z".

endTime

string (Timestamp format)

End of the period.

A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds. Example: "2014-10-02T15:01:23.045123456Z".

Was this page helpful? Let us know how we did:

Send feedback about...

Job search v3 documentation