Method: properties.runFunnelReport

string

Optional. A Google Analytics property identifier whose events are tracked. Specified in the URL path and not the body. To learn more, see where to find your Property ID. Within a batch request, this property should either be unspecified or consistent with the batch-level property.

Example: properties/1234

{
  "isOpenFunnel": boolean,
  "steps": [
    {
      object (FunnelStep)
    }
  ]
}

boolean

In an open funnel, users can enter the funnel in any step, and in a closed funnel, users must enter the funnel in the first step. Optional. If unspecified, a closed funnel is used.

object (FunnelStep)

The sequential steps of this funnel.

{
  "name": string,
  "isDirectlyFollowedBy": boolean,
  "filterExpression": {
    object (FunnelFilterExpression)
  },
  "withinDurationFromPriorStep": string
}

string

The distinctive name for this step. If unspecified, steps will be named by a 1 based indexed name (for example "0. ", "1. ", etc.). This name defines string value returned by the funnelStepName dimension. For example, specifying name = Purchase in the request's third funnel step will produce 3. Purchase in the funnel report response.

boolean

If true, this step must directly follow the previous step. If false, there can be events between the previous step and this step. If unspecified, isDirectlyFollowedBy is treated as false.

object (FunnelFilterExpression)

The condition that your users must meet to be included in this step of the funnel journey.

string (Duration format)

If specified, this step must complete within this duration of the completion of the prior step. withinDurationFromPriorStep is inclusive of the endpoint at the microsecond granularity. For example a duration of 5 seconds can be completed at 4.9 or 5.0 seconds, but not 5 seconds and 1 microsecond.

withinDurationFromPriorStep is optional, and if unspecified, steps may be separated by any time duration.

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

{

  // Union field expr can be only one of the following:
  "andGroup": {
    object (FunnelFilterExpressionList)
  },
  "orGroup": {
    object (FunnelFilterExpressionList)
  },
  "notExpression": {
    object (FunnelFilterExpression)
  },
  "funnelFieldFilter": {
    object (FunnelFieldFilter)
  },
  "funnelEventFilter": {
    object (FunnelEventFilter)
  }
  // End of list of possible types for union field expr.
}

object (FunnelFilterExpressionList)

The FunnelFilterExpression in andGroup have an AND relationship.

object (FunnelFilterExpressionList)

The FunnelFilterExpression in orGroup have an OR relationship.

object (FunnelFilterExpression)

The FunnelFilterExpression is NOT of notExpression.

object (FunnelFieldFilter)

A funnel filter for a dimension or metric.

object (FunnelEventFilter)

Creates a filter that matches events of a single event name. If a parameter filter expression is specified, only the subset of events that match both the single event name and the parameter filter expressions match this event filter.

{
  "expressions": [
    {
      object (FunnelFilterExpression)
    }
  ]
}

object (FunnelFilterExpression)

The list of funnel filter expressions.

{
  "fieldName": string,

  // Union field one_filter can be only one of the following:
  "stringFilter": {
    object (StringFilter)
  },
  "inListFilter": {
    object (InListFilter)
  },
  "numericFilter": {
    object (NumericFilter)
  },
  "betweenFilter": {
    object (BetweenFilter)
  }
  // End of list of possible types for union field one_filter.
}

string

The dimension name or metric name.

object (StringFilter)

Strings related filter.

object (InListFilter)

A filter for in list values.

object (NumericFilter)

A filter for numeric or date values.

object (BetweenFilter)

A filter for between two values.

{
  "eventName": string,
  "funnelParameterFilterExpression": {
    object (FunnelParameterFilterExpression)
  }
}

string

This filter matches events of this single event name. Event name is required.

object (FunnelParameterFilterExpression)

If specified, this filter matches events that match both the single event name and the parameter filter expressions.

Inside the parameter filter expression, only parameter filters are available.

{

  // Union field expr can be only one of the following:
  "andGroup": {
    object (FunnelParameterFilterExpressionList)
  },
  "orGroup": {
    object (FunnelParameterFilterExpressionList)
  },
  "notExpression": {
    object (FunnelParameterFilterExpression)
  },
  "funnelParameterFilter": {
    object (FunnelParameterFilter)
  }
  // End of list of possible types for union field expr.
}

object (FunnelParameterFilterExpressionList)

The FunnelParameterFilterExpression in andGroup have an AND relationship.

object (FunnelParameterFilterExpressionList)

The FunnelParameterFilterExpression in orGroup have an OR relationship.

object (FunnelParameterFilterExpression)

The FunnelParameterFilterExpression is NOT of notExpression.

object (FunnelParameterFilter)

A primitive funnel parameter filter.

{
  "expressions": [
    {
      object (FunnelParameterFilterExpression)
    }
  ]
}

object (FunnelParameterFilterExpression)

The list of funnel parameter filter expressions.

{

  // Union field one_parameter can be only one of the following:
  "eventParameterName": string,
  "itemParameterName": string
  // End of list of possible types for union field one_parameter.

  // Union field one_filter can be only one of the following:
  "stringFilter": {
    object (StringFilter)
  },
  "inListFilter": {
    object (InListFilter)
  },
  "numericFilter": {
    object (NumericFilter)
  },
  "betweenFilter": {
    object (BetweenFilter)
  }
  // End of list of possible types for union field one_filter.
}

string

This filter will be evaluated on the specified event parameter. Event parameters are logged as parameters of the event. Event parameters include fields like "firebase_screen" & "currency".

Event parameters can only be used in segments & funnels and can only be used in a descendent filter from an EventFilter. In a descendent filter from an EventFilter either event or item parameters should be used.

string

This filter will be evaluated on the specified item parameter. Item parameters are logged as parameters in the item array. Item parameters include fields like "item_name" & "item_category".

Item parameters can only be used in segments & funnels and can only be used in a descendent filter from an EventFilter. In a descendent filter from an EventFilter either event or item parameters should be used.

Item parameters are only available in ecommerce events. To learn more about ecommerce events, see the Measure ecommerce guide.

object (StringFilter)

Strings related filter.

object (InListFilter)

A filter for in list values.

object (NumericFilter)

A filter for numeric or date values.

object (BetweenFilter)

A filter for between two values.

{
  "breakdownDimension": {
    object (Dimension)
  },
  "limit": string
}

object (Dimension)

The dimension column added to the funnel table sub report response. The breakdown dimension breaks down each funnel step. A valid breakdownDimension is required if funnelBreakdown is specified.

string (int64 format)

The maximum number of distinct values of the breakdown dimension to return in the response. A limit of 5 is used if limit is not specified. Limit must exceed zero and cannot exceed 15.

{
  "nextActionDimension": {
    object (Dimension)
  },
  "limit": string
}

object (Dimension)

The dimension column added to the funnel visualization sub report response. The next action dimension returns the next dimension value of this dimension after the user has attained the ith funnel step.

nextActionDimension currently only supports eventName and most Page / Screen dimensions like pageTitle and pagePath. nextActionDimension cannot be a dimension expression.

string (int64 format)

The maximum number of distinct values of the breakdown dimension to return in the response. A limit of 5 is used if limit is not specified. Limit must exceed zero and cannot exceed 5.

{
  "name": string,

  // Union field one_segment_scope can be only one of the following:
  "userSegment": {
    object (UserSegment)
  },
  "sessionSegment": {
    object (SessionSegment)
  },
  "eventSegment": {
    object (EventSegment)
  }
  // End of list of possible types for union field one_segment_scope.
}

string

The name for this segment. If unspecified, segments are named "Segment". This name defines string value returned by the segment dimension. The segment dimension prefixes segment names by the 1-based index number of the segment in the request (for example "1. Segment", "2. Segment", etc.).

object (UserSegment)

User segments are subsets of users who engaged with your site or app.

object (SessionSegment)

Session segments are subsets of the sessions that occurred on your site or app.

object (EventSegment)

Event segments are subsets of events that were triggered on your site or app.

{
  "userInclusionCriteria": {
    object (UserSegmentCriteria)
  },
  "exclusion": {
    object (UserSegmentExclusion)
  }
}

object (UserSegmentCriteria)

Defines which users are included in this segment. Optional.

object (UserSegmentExclusion)

Defines which users are excluded in this segment. Optional.

{
  "andConditionGroups": [
    {
      object (UserSegmentConditionGroup)
    }
  ],
  "andSequenceGroups": [
    {
      object (UserSegmentSequenceGroup)
    }
  ]
}

object (UserSegmentConditionGroup)

A user matches this criteria if the user matches each of these andConditionGroups and each of the andSequenceGroups. andConditionGroups may be empty if andSequenceGroups are specified.

object (UserSegmentSequenceGroup)

A user matches this criteria if the user matches each of these andSequenceGroups and each of the andConditionGroups. andSequenceGroups may be empty if andConditionGroups are specified.

{
  "conditionScoping": enum (UserCriteriaScoping),
  "segmentFilterExpression": {
    object (SegmentFilterExpression)
  }
}

enum (UserCriteriaScoping)

Data is included or excluded from the segment based on if it matches the condition group. This scoping defines how many events the segmentFilterExpression is evaluated on before the condition group is determined to be matched or not. For example if conditionScoping = USER_CRITERIA_WITHIN_SAME_SESSION, the expression is evaluated on all events in a session, and then, the condition group is determined to be matched or not for this user. For example if conditionScoping = USER_CRITERIA_WITHIN_SAME_EVENT, the expression is evaluated on a single event, and then, the condition group is determined to be matched or not for this user.

Optional. If unspecified, conditionScoping = ACROSS_ALL_SESSIONS is used.

object (SegmentFilterExpression)

Data is included or excluded from the segment based on if it matches this expression. Expressions express criteria on dimension, metrics, and/or parameters.

{

  // Union field expr can be only one of the following:
  "andGroup": {
    object (SegmentFilterExpressionList)
  },
  "orGroup": {
    object (SegmentFilterExpressionList)
  },
  "notExpression": {
    object (SegmentFilterExpression)
  },
  "segmentFilter": {
    object (SegmentFilter)
  },
  "segmentEventFilter": {
    object (SegmentEventFilter)
  }
  // End of list of possible types for union field expr.
}

object (SegmentFilterExpressionList)

The SegmentFilterExpression in andGroup have an AND relationship.

object (SegmentFilterExpressionList)

The SegmentFilterExpression in orGroup have an OR relationship.

object (SegmentFilterExpression)

The SegmentFilterExpression is NOT of notExpression.

object (SegmentFilter)

A primitive segment filter.

object (SegmentEventFilter)

Creates a filter that matches events of a single event name. If a parameter filter expression is specified, only the subset of events that match both the single event name and the parameter filter expressions match this event filter.

{
  "expressions": [
    {
      object (SegmentFilterExpression)
    }
  ]
}

object (SegmentFilterExpression)

The list of segment filter expressions

{
  "fieldName": string,
  "filterScoping": {
    object (SegmentFilterScoping)
  },

  // Union field one_filter can be only one of the following:
  "stringFilter": {
    object (StringFilter)
  },
  "inListFilter": {
    object (InListFilter)
  },
  "numericFilter": {
    object (NumericFilter)
  },
  "betweenFilter": {
    object (BetweenFilter)
  }
  // End of list of possible types for union field one_filter.
}

string

The dimension name or metric name.

object (SegmentFilterScoping)

Specifies the scope for the filter.

object (StringFilter)

Strings related filter.

object (InListFilter)

A filter for in list values.

object (NumericFilter)

A filter for numeric or date values.

object (BetweenFilter)

A filter for between two values.

{
  "atAnyPointInTime": boolean
}

boolean

If atAnyPointInTime is true, this filter evaluates to true for all events if it evaluates to true for any event in the date range of the request.

This atAnyPointInTime parameter does not extend the date range of events in the report. If atAnyPointInTime is true, only events within the report's date range are considered when evaluating this filter.

This atAnyPointInTime is only able to be specified if the criteria scoping is ACROSS_ALL_SESSIONS and is not able to be specified in sequences.

If the criteria scoping is ACROSS_ALL_SESSIONS, atAnyPointInTime = false is used if unspecified.

{
  "eventName": string,
  "segmentParameterFilterExpression": {
    object (SegmentParameterFilterExpression)
  }
}

string

This filter matches events of this single event name. Event name is required.

object (SegmentParameterFilterExpression)

If specified, this filter matches events that match both the single event name and the parameter filter expressions.

Inside the parameter filter expression, only parameter filters are available.

{

  // Union field expr can be only one of the following:
  "andGroup": {
    object (SegmentParameterFilterExpressionList)
  },
  "orGroup": {
    object (SegmentParameterFilterExpressionList)
  },
  "notExpression": {
    object (SegmentParameterFilterExpression)
  },
  "segmentParameterFilter": {
    object (SegmentParameterFilter)
  }
  // End of list of possible types for union field expr.
}

object (SegmentParameterFilterExpressionList)

The SegmentParameterFilterExpression in andGroup have an AND relationship.

object (SegmentParameterFilterExpressionList)

The SegmentParameterFilterExpression in orGroup have an OR relationship.

object (SegmentParameterFilterExpression)

The SegmentParameterFilterExpression is NOT of notExpression.

object (SegmentParameterFilter)

A primitive segment parameter filter.

{
  "expressions": [
    {
      object (SegmentParameterFilterExpression)
    }
  ]
}

object (SegmentParameterFilterExpression)

The list of segment parameter filter expressions.

{
  "filterScoping": {
    object (SegmentParameterFilterScoping)
  },

  // Union field one_parameter can be only one of the following:
  "eventParameterName": string,
  "itemParameterName": string
  // End of list of possible types for union field one_parameter.

  // Union field one_filter can be only one of the following:
  "stringFilter": {
    object (StringFilter)
  },
  "inListFilter": {
    object (InListFilter)
  },
  "numericFilter": {
    object (NumericFilter)
  },
  "betweenFilter": {
    object (BetweenFilter)
  }
  // End of list of possible types for union field one_filter.
}

object (SegmentParameterFilterScoping)

Specifies the scope for the filter.

string

This filter will be evaluated on the specified event parameter. Event parameters are logged as parameters of the event. Event parameters include fields like "firebase_screen" & "currency".

Event parameters can only be used in segments & funnels and can only be used in a descendent filter from an EventFilter. In a descendent filter from an EventFilter either event or item parameters should be used.

string

This filter will be evaluated on the specified item parameter. Item parameters are logged as parameters in the item array. Item parameters include fields like "item_name" & "item_category".

Item parameters can only be used in segments & funnels and can only be used in a descendent filter from an EventFilter. In a descendent filter from an EventFilter either event or item parameters should be used.

Item parameters are only available in ecommerce events. To learn more about ecommerce events, see the Measure ecommerce guide.

object (StringFilter)

Strings related filter.

object (InListFilter)

A filter for in list values.

object (NumericFilter)

A filter for numeric or date values.

object (BetweenFilter)

A filter for between two values.

{
  "inAnyNDayPeriod": string
}

string (int64 format)

Accumulates the parameter over the specified period of days before applying the filter. Only supported if criteria scoping is ACROSS_ALL_SESSIONS or WITHIN_SAME_SESSION. Only supported if the parameter is event_count.

For example if inAnyNDayPeriod is 3, the eventName is "purchase", the event parameter is "event_count", and the Filter's criteria is greater than 5, this filter will accumulate the event count of purchase events over every 3 consecutive day period in the report's date range; a user will pass this Filter's criteria to be included in this segment if their count of purchase events exceeds 5 in any 3 consecutive day period. For example, the periods 2021-11-01 to 2021-11-03, 2021-11-02 to 2021-11-04, 2021-11-03 to 2021-11-05, and etc. will be considered.

The date range is not extended for the purpose of having a full N day window near the start of the date range. For example if a report is for 2021-11-01 to 2021-11-10 and inAnyNDayPeriod = 3, the first two day period will be effectively shortened because no event data outside the report's date range will be read. For example, the first four periods will effectively be: 2021-11-01 to 2021-11-01, 2021-11-01 to 2021-11-02, 2021-11-01 to 2021-11-03, and 2021-11-02 to 2021-11-04.

inAnyNDayPeriod is optional. If not specified, the segmentParameterFilter is applied to each event individually.

{
  "sequenceScoping": enum (UserCriteriaScoping),
  "sequenceMaximumDuration": string,
  "userSequenceSteps": [
    {
      object (UserSequenceStep)
    }
  ]
}

enum (UserCriteriaScoping)

All sequence steps must be satisfied in the scoping for the user to match the sequence. For example if sequenceScoping = USER_CRITERIA_WITHIN_SAME_SESSION, all sequence steps must complete within one session for the user to match the sequence. sequenceScoping = USER_CRITERIA_WITHIN_SAME_EVENT is not supported.

Optional. If unspecified, conditionScoping = ACROSS_ALL_SESSIONS is used.

string (Duration format)

Defines the time period in which the whole sequence must occur; for example, 30 Minutes. sequenceMaximumDuration is inclusive of the endpoint at the microsecond granularity. For example a sequence with a maximum duration of 5 seconds can be completed at 4.9 or 5.0 seconds, but not 5 seconds and 1 microsecond.

sequenceMaximumDuration is optional, and if unspecified, sequences can be completed in any time duration.

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

object (UserSequenceStep)

An ordered sequence of condition steps. A user's events must complete each step in order for the user to match the UserSegmentSequenceGroup.

{
  "isDirectlyFollowedBy": boolean,
  "stepScoping": enum (UserCriteriaScoping),
  "segmentFilterExpression": {
    object (SegmentFilterExpression)
  }
}

boolean

If true, the event satisfying this step must be the very next event after the event satifying the last step. If false, this step indirectly follows the prior step; for example, there may be events between the prior step and this step. isDirectlyFollowedBy must be false for the first step.

enum (UserCriteriaScoping)

This sequence step must be satisfied in the scoping for the user to match the sequence. For example if sequenceScoping = WITHIN_SAME_SESSION, this sequence steps must complete within one session for the user to match the sequence. stepScoping = ACROSS_ALL_SESSIONS is only allowed if the sequenceScoping = ACROSS_ALL_SESSIONS.

Optional. If unspecified, stepScoping uses the same UserCriteriaScoping as the sequenceScoping.

object (SegmentFilterExpression)

A user matches this sequence step if their events match this expression. Expressions express criteria on dimension, metrics, and/or parameters.

{
  "userExclusionDuration": enum (UserExclusionDuration),
  "userExclusionCriteria": {
    object (UserSegmentCriteria)
  }
}

enum (UserExclusionDuration)

Specifies how long an exclusion will last if a user matches the userExclusionCriteria.

Optional. If unspecified, userExclusionDuration of USER_EXCLUSION_TEMPORARY is used.

object (UserSegmentCriteria)

If a user meets this condition, the user is excluded from membership in the segment for the userExclusionDuration.

{
  "sessionInclusionCriteria": {
    object (SessionSegmentCriteria)
  },
  "exclusion": {
    object (SessionSegmentExclusion)
  }
}

object (SessionSegmentCriteria)

Defines which sessions are included in this segment. Optional.

object (SessionSegmentExclusion)

Defines which sessions are excluded in this segment. Optional.

{
  "andConditionGroups": [
    {
      object (SessionSegmentConditionGroup)
    }
  ]
}

object (SessionSegmentConditionGroup)

A session matches this criteria if the session matches each of these andConditionGroups.

{
  "conditionScoping": enum (SessionCriteriaScoping),
  "segmentFilterExpression": {
    object (SegmentFilterExpression)
  }
}

enum (SessionCriteriaScoping)

Data is included or excluded from the segment based on if it matches the condition group. This scoping defines how many events the segmentFilterExpression is evaluated on before the condition group is determined to be matched or not. For example if conditionScoping = SESSION_CRITERIA_WITHIN_SAME_SESSION, the expression is evaluated on all events in a session, and then, the condition group is determined to be matched or not for this session. For example if conditionScoping = SESSION_CRITERIA_WITHIN_SAME_EVENT, the expression is evaluated on a single event, and then, the condition group is determined to be matched or not for this session.

Optional. If unspecified, a conditionScoping of WITHIN_SAME_SESSION is used.

object (SegmentFilterExpression)

Data is included or excluded from the segment based on if it matches this expression. Expressions express criteria on dimension, metrics, and/or parameters.

{
  "sessionExclusionDuration": enum (SessionExclusionDuration),
  "sessionExclusionCriteria": {
    object (SessionSegmentCriteria)
  }
}

enum (SessionExclusionDuration)

Specifies how long an exclusion will last if a session matches the sessionExclusionCriteria.

Optional. If unspecified, a sessionExclusionDuration of SESSION_EXCLUSION_TEMPORARY is used.

object (SessionSegmentCriteria)

If a session meets this condition, the session is excluded from membership in the segment for the sessionExclusionDuration.

{
  "eventInclusionCriteria": {
    object (EventSegmentCriteria)
  },
  "exclusion": {
    object (EventSegmentExclusion)
  }
}

object (EventSegmentCriteria)

Defines which events are included in this segment. Optional.

object (EventSegmentExclusion)

Defines which events are excluded in this segment. Optional.

{
  "andConditionGroups": [
    {
      object (EventSegmentConditionGroup)
    }
  ]
}

object (EventSegmentConditionGroup)

An event matches this criteria if the event matches each of these andConditionGroups.

{
  "conditionScoping": enum (EventCriteriaScoping),
  "segmentFilterExpression": {
    object (SegmentFilterExpression)
  }
}

enum (EventCriteriaScoping)

conditionScoping should always be EVENT_CRITERIA_WITHIN_SAME_EVENT.

Optional. If unspecified, a conditionScoping of EVENT_CRITERIA_WITHIN_SAME_EVENT is used.

object (SegmentFilterExpression)

Data is included or excluded from the segment based on if it matches this expression. Expressions express criteria on dimension, metrics, and/or parameters.

{
  "eventExclusionDuration": enum (EventExclusionDuration),
  "eventExclusionCriteria": {
    object (EventSegmentCriteria)
  }
}

enum (EventExclusionDuration)

eventExclusionDuration should always be PERMANENTLY_EXCLUDE.

Optional. If unspecified, an eventExclusionDuration of EVENT_EXCLUSION_PERMANENT is used.

object (EventSegmentCriteria)

If an event meets this condition, the event is excluded from membership in the segment for the eventExclusionDuration.

{
  "dimensionHeaders": [
    {
      object (DimensionHeader)
    }
  ],
  "metricHeaders": [
    {
      object (MetricHeader)
    }
  ],
  "rows": [
    {
      object (Row)
    }
  ],
  "metadata": {
    object (FunnelResponseMetadata)
  }
}

object (DimensionHeader)

Describes dimension columns. Funnel reports always include the funnel step dimension in sub report responses. Additional dimensions like breakdowns, dates, and next actions may be present in the response if requested.

object (MetricHeader)

Describes metric columns. Funnel reports always include active users in sub report responses. The funnel table includes additional metrics like completion rate, abandonments, and abandonments rate.

object (Row)

Rows of dimension value combinations and metric values in the report.

object (FunnelResponseMetadata)

Metadata for the funnel report.

{
  "samplingMetadatas": [
    {
      object (SamplingMetadata)
    }
  ]
}

object (SamplingMetadata)

If funnel report results are sampled, this describes what percentage of events were used in this funnel report. One samplingMetadatas is populated for each date range. Each samplingMetadatas corresponds to a date range in order that date ranges were specified in the request.

However if the results are not sampled, this field will not be defined.