Wowza ClearCaster GraphQL API resource limitations

Learn about working with resource limitations in the Wowza ClearCaster™ GraphQL API for Wowza ClearCaster appliances.

Note:  Wowza ClearCaster version 2.0.0.07 or later is required.

About Wowza ClearCaster GraphQL API resource limitations

---

Operations performed with the Wowza ClearCaster GraphQL API are subject to limitations that protect shared server resources. This article provides an overview of current methods for calculating and tracking API rate limits, however, limitations and the formula used to calculate them are subject to change without notice.

The Wowza ClearCaster GraphQL API uses rate limits set per namespace for operations that use API keys. The rate limit is an amount of operation cost that you can perform in one minute of UTC time.

Note: Operations originating from the Wowza ClearCaster Manager don't count towards the limit set for a namespace.

Rate limit calculations

---

Each operation has a calculated cost according to these factors:

• Number of fields - The more data you request, the higher the cost.
• Type of operation - Mutations have a higher cost than queries or subscriptions.
• Depth - The more levels deep the query is, the higher the cost. We recommend operations no more than four levels deep.

Here are some examples of operations and their calculated costs:

• Calculated cost for the following activateBroadcastEncoders example query: 21

  mutation activateBroadcastEncoders {
    activateBroadcastEncoders(broadcastId: "yourBroadcastId") {
      id
      broadcastEncoders {
        id
        encoder {
          id
          deviceId
          name
        }
      }
    }
  }

• Calculated cost for the following createBroadcast example mutation: 12

  mutation createBroadcast {
    createBroadcast(namespaceId: "yourNamespaceId", 
      input: {
        name: "broadcastName", 
        inputs: {
          inputType: CAPTURE_HARDWARE,
          videoFrameWidthMax: 1920, 
          videoFrameHeightMax: 1080, 
          videoFrameRateMax: 30, 
          broadcastInputEncoderIndex: 0
          }, 
        broadcastEncoders: [
          {
          encoderId: "yourEncoderId",
          streamTargetEncoderIndex: 0,
          broadcastInputEncoderIndex: 0
          }
        ],
        outputs: [
          {
            streamName: "1080p30", 
            streamTargets:[
              {
                url: "rtmp://sourceURL",
                streamName: "yourStreamName",
                protocol: RTMP,
                streamTargetEncoderIndex: 0,
              },
          ],
            encodingConfiguration: 
            {
              name: "1080p30", 
              encodingConfigurationVideo: 
              {
                codec: "H.264", 
                implementation: "x264", 
                frameSizeFitMode: "stretch", 
                frameSizeWidth: 1920, 
                frameSizeHeight: 1080, 
                profile: "main", 
                bitrate: 8000000, 
                bitrateMin: 1000000, 
                autoAdjustBitrate: true, 
                keyFrameIntervalFollowSource: true, 
                keyFrameInterval: 60,
                parameters: [
                  {
                    name: "x264.preset", 
                    value: "3", 
                    type: "Long"
                  },
                  {
                    name: "x264.ref", 
                    value: "1", 
                    type: "Long"
                  },
                  {
                    name: "x264.bframes", 
                    value: "1", 
                    type: "Long"
                  }
                ]
              }, 
              encodingConfigurationAudio: 
              {
                codec: "AAC", 
                bitrate: 96000
              }
            }
          }
        ]
      }
    ) {
        id
        name
    }
  }

• Calculated cost for the following setBroadcastStatus example query: 15

  mutation setBroadcastStatusIDLE {
    setBroadcastStatus(broadcastId: "yourBroadcastId", status: IDLE) {
      id
      status
      liveAt
      previewedAt
      stoppedAt
    }
  }

• Calculated cost for the following allNamespaces example query: 10

  query allNamespaces {
    allNamespaces {
      id
      name
    }
  }

• Calculated cost for the following simple allBroadcasts example query: 10

  query allBroadcasts {
    allBroadcasts {
      id
      name
    }
  }

• Calculated cost for the following complex allBroadcasts example query: 71

  query allBroadcasts {
    allBroadcasts {
      id
      name
      inputs {
          inputType
          videoInput
          videoFrameWidthMax
          videoFrameHeightMax
          videoFrameRateMax
          videoAspectRatioMode
          videoAspectRatioWidth
          videoAspectRatioHeight
          videoAspectRatioRotation
          audioLevel
          overlayVendor
          overlayUrl
      }
      outputs {
        id
        encodingConfiguration {
          name
          encodingConfigurationVideo {
            codec
            bitrate
          }
          encodingConfigurationAudio {
            codec
            bitrate
          }
        }
        streamTargets {
          id
          url
          protocol
          streamTargetEncoderIndex
        }
        recordings {
          id
          format
        }
      }
      displays {
        id
      }
      broadcastEncoders {
        id
        streamTargetEncoderIndex
        broadcastInputEncoderIndex
        encoder {
          id
          deviceId
          name
        }
      }
    }
  }

Check rate limit status

---

You can check the status of rate limit cost consumption for the operations you perform by inspecting the HTTP response headers.

Header name	Description
x-rate-limit-cost-consumed	The current amount of cost consumed from the limit
x-rate-limit-cost-limit	The current cost limit per minute set for the namespace by Wowza
x-rate-limit-cost-request	The cost of the current request
x-rate-limit-cost-reset	The amount of time, in milliseconds, until the cost consumed resets

If you perform an operation in GraphiQL, you can use the Chrome DevTools Network panel to view the response headers.

Exceeded rate limits

---

If you perform an operation that exceeds the one-minute rate limit set for your namespace, your operation will return a 429 "Rate Limit Reached" error.