Genesys Cloud - Developer Community!

 View Only

Sign Up

  • 1.  Number of Platform API requests generated per Embeddable Framework method / action

    Posted 09-08-2026 22:17

    Hi team,

    We are implementing a private deployment of the Genesys Cloud Embeddable Framework - framework.js is registered to our own Genesys Cloud org, and GCEF is displayed inside an iframe within our CRM screen. We are aware the deployment model may affect the answers, so please assume private deployment throughout.

    The Resource Center notes that Embeddable Framework applications are subject to API usage allocations (API Usage view). Our concern is that a high-volume contact center deployment could generate significantly more API traffic than expected, so we want to quantify this before go-live rather than discover it afterwards. To do that, we need to understand how many Platform API requests each GCEF operation generates per invocation. We will apply our own volume figures to that, so we are not asking anyone to size our deployment.

    We raised a support case and were advised that API usage depends on configuration, and that this forum is the right place to discuss it with the product management and development teams.

    1. Per-invocation request counts

    For each of the following, could you clarify how many Platform API requests are issued per invocation, and whether they count toward API usage allocations?

    # Type Item
    1 Method initialSetup
    2 Action clickToDial
    3 Action Interaction.addCustomAttributes
    4 Action addTransferContext
    5 Action User.updateStatus
    6 Action Interaction.updateState
    7 Method screenPop

    Two points we are particularly unsure about:

    • initialSetup: does initialization itself issue requests (token exchange, session establishment, etc.), and if so, roughly how many?
    • screenPop: this is triggered by GCEF internally rather than invoked by our integration - does it still consume usage on our side?

    2. Event subscriptions

    For subscribe - Interaction (add, change, connect, disconnect, acw, deallocate, consultTransfer, completeConsultTransfer) and subscribe - UserAction (login, logout, station, status, routingStatus, view):

    • Is usage counted once at subscription registration, or per callback invocation?
    • If per callback, is one request counted per event delivered? For a single interaction traversing multiple states, would each state transition be counted separately?
    • Does subscribing to more event types increase usage, or is the cost independent of the number of subscribed events?
    • Are these delivered over the notifications/WebSocket channel rather than as REST requests - and if so, are they counted differently from Platform API requests?

    3. Standard GCEF UI operations

    When an agent operates the built-in GCEF interface directly (answer, hold, transfer, etc.), is the resulting traffic attributed to our integration's API usage, or treated as normal client activity?

    4. Does configuration affect the counts above?

    Support advised us that API usage depends on configuration. We understand the configuration properties themselves (settings, customInteractionAttributes, and so on) are client-side declarations applied at initialSetup, and are not billable requests in their own right.

    However, we would like to confirm whether their content changes the number of API requests generated by the actions and subscriptions above - for example, whether enabling additional settings features, or declaring a larger number of customInteractionAttributes, increases the per-invocation request count.

    More broadly, what configuration or design choices most significantly increase or decrease an Embeddable Framework integration's API footprint? Any anti-patterns worth avoiding would be very helpful.

    Thanks in advance.


    #EmbeddableFramework
    #PlatformAPI

    ------------------------------
    健司
    ------------------------------


  • 2.  RE: Number of Platform API requests generated per Embeddable Framework method / action

    Posted 09-10-2026 15:24

    Hi,

    Apologies about the wall of text, but there are a lot of good questions in your thread I want to help with. 

    First, you are correct that a private Genesys Cloud Embeddable Framework deployment is subject to API usage allocations.

    The important distinction here is that API usage is measured on the Platform API requests made by the OAuth client, rather than on the individual GCEF method, action, or event itself. The API Usage view records the PUT, POST, GET, and DELETE requests made by OAuth clients.

    Because of that, there isn't a documented fixed request count that I can give you for initialSetup, clickToDial, Interaction.addCustomAttributes, addTransferContext, User.updateStatus, Interaction.updateState, or screenPop. Genesys doesn't document a fixed number of Platform API requests for each GCEF action, so there isn't a reliable per-action request count we can provide.

    The same distinction is important for subscriptions. A callback from an Interaction or UserAction subscription isn't itself equivalent to another REST API request through the OAuth. I wouldn't model API allocation as "one request per event received." What matters for the allocation is the actual Platform API traffic generated by the client.

    For the built-in GCEF UI, I also wouldn't assume that an agent action such as Answer, Hold, or Transfer is exempt simply because it originated from the embedded UI. Genesys specifically calls out Embeddable Framework applications as being subject to API usage allocations, unlike the Genesys Cloud browser/web/mobile apps and the explicitly excluded pre-built integrations.

    Configuration can certainly affect overall API traffic because it can change the behavior exercised by the framework, but there isn't a supported formula such as "each custom attribute adds one request" or "enabling this setting adds X requests." I wouldn't recommend building a capacity model around assumptions at that level.

    For your pre-production (sandbox) testing, I recommend using a dedicated OAuth client in your test environment, exercise the same GCEF configuration and workflows you expect in production, and use the API Usage view to measure the requests generated by that client. The view lets you drill into both the OAuth client and the individual API requests, which should give you a much more reliable baseline than trying to derive request counts from the GCEF JavaScript methods. If you need more info on the API usage view, please see the documentation below:

    API Usage view

    About APIs and API usage

    There is a lot to unpack here, so here is the summary of the above: 

    Genesys Cloud emebbedable framework is subject to API usage allocations through the OAuth Requests, but there isn't a documented per-GCEF-operation request-count contract. For sizing, measure the actual Platform API traffic generated by your private deployment and configuration rather than assuming a fixed mapping between GCEF actions/events and API requests.

    Hope this helps!



    ------------------------------
    Cameron
    Online Community Manager/Moderator
    ------------------------------



  • 3.  RE: Number of Platform API requests generated per Embeddable Framework method / action

    Posted 09-14-2026 02:06

    Hi Cameron,

    No apology needed - this was exactly the kind of answer we were looking for, and it corrected a misconception on our side that would have led us down the wrong path.

    The key takeaway for us is that API usage is measured on the Platform API requests issued by the OAuth client, not on the GCEF methods, actions, or events themselves. We had been trying to build a capacity model as "per-operation request count × expected daily volume," and it's now clear that no such fixed mapping exists, by design. We'll stop pursuing that approach.

    Your point about subscriptions was particularly helpful. We had flagged subscribe - Interaction and subscribe - UserAction as unknowns in our estimate precisely because we couldn't determine whether each delivered event counted as a request. Knowing that we shouldn't model it as "one request per event received" saves us from a significant overestimate.

    The note about built-in GCEF UI actions not being exempt was also useful - that widens the scope of what we need to account for, and we'll plan on that basis.

    We'll take your recommendation and treat measurement, rather than derivation, as the way to establish a baseline: a dedicated OAuth client, our intended configuration and workflows, and the API Usage view.

    Thanks for taking the time to write all of this out. It was genuinely useful.



    ------------------------------
    健司
    ------------------------------