> ## Documentation Index
> Fetch the complete documentation index at: https://developers.telnyx.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Display information about allocatable global outbound channels for the current user.

> Display information about allocatable global outbound channels for the current user. Only usable by account managers.



## OpenAPI

````yaml https://telnyx-openapi-ng.s3.us-east-1.amazonaws.com/account-billing/managed-accounts.yml get /managed_accounts/allocatable_global_outbound_channels
openapi: 3.1.0
info:
  title: Telnyx Managed Accounts API
  version: 2.0.0
  description: API for Managed accounts.
  contact:
    email: support@telnyx.com
servers:
  - url: https://api.telnyx.com/v2
security:
  - bearerAuth: []
paths:
  /managed_accounts/allocatable_global_outbound_channels:
    get:
      tags:
        - Managed Accounts
      summary: >-
        Display information about allocatable global outbound channels for the
        current user.
      description: >-
        Display information about allocatable global outbound channels for the
        current user. Only usable by account managers.
      operationId: ListAllocatableGlobalOutboundChannels
      responses:
        '200':
          $ref: >-
            #/components/responses/ListManagedAccountsAllocatableGlobalOutboundChannelsResponse
        '401':
          $ref: '#/components/responses/managed-accounts_UnauthorizedResponse'
        '403':
          $ref: '#/components/responses/managed-accounts_ForbiddenResponse'
      x-codeSamples:
        - lang: JavaScript
          source: >-
            import Telnyx from 'telnyx';


            const client = new Telnyx({
              apiKey: process.env['TELNYX_API_KEY'], // This is the default and can be omitted
            });


            const response = await
            client.managedAccounts.getAllocatableGlobalOutboundChannels();


            console.log(response.data);
        - lang: Python
          source: >-
            import os

            from telnyx import Telnyx


            client = Telnyx(
                api_key=os.environ.get("TELNYX_API_KEY"),  # This is the default and can be omitted
            )

            response =
            client.managed_accounts.get_allocatable_global_outbound_channels()

            print(response.data)
        - lang: Go
          source: "package main\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\n\t\"github.com/team-telnyx/telnyx-go\"\n\t\"github.com/team-telnyx/telnyx-go/option\"\n)\n\nfunc main() {\n\tclient := telnyx.NewClient(\n\t\toption.WithAPIKey(\"My API Key\"),\n\t)\n\tresponse, err := client.ManagedAccounts.GetAllocatableGlobalOutboundChannels(context.TODO())\n\tif err != nil {\n\t\tpanic(err.Error())\n\t}\n\tfmt.Printf(\"%+v\\n\", response.Data)\n}\n"
        - lang: Java
          source: >-
            package com.telnyx.sdk.example;


            import com.telnyx.sdk.client.TelnyxClient;

            import com.telnyx.sdk.client.okhttp.TelnyxOkHttpClient;

            import
            com.telnyx.sdk.models.managedaccounts.ManagedAccountGetAllocatableGlobalOutboundChannelsParams;

            import
            com.telnyx.sdk.models.managedaccounts.ManagedAccountGetAllocatableGlobalOutboundChannelsResponse;


            public final class Main {
                private Main() {}

                public static void main(String[] args) {
                    TelnyxClient client = TelnyxOkHttpClient.fromEnv();

                    ManagedAccountGetAllocatableGlobalOutboundChannelsResponse response = client.managedAccounts().getAllocatableGlobalOutboundChannels();
                }
            }
        - lang: Ruby
          source: >-
            require "telnyx"


            telnyx = Telnyx::Client.new(api_key: "My API Key")


            response =
            telnyx.managed_accounts.get_allocatable_global_outbound_channels


            puts(response)
        - lang: PHP
          source: >-
            <?php


            require_once dirname(__DIR__) . '/vendor/autoload.php';


            use Telnyx\Client;

            use Telnyx\Core\Exceptions\APIException;


            $client = new Client(apiKey: getenv('TELNYX_API_KEY') ?: 'My API
            Key');


            try {
              $response = $client->managedAccounts->getAllocatableGlobalOutboundChannels();

              var_dump($response);
            } catch (APIException $e) {
              echo $e->getMessage();
            }
        - lang: CLI
          source: |-
            telnyx managed-accounts get-allocatable-global-outbound-channels \
              --api-key 'My API Key'
components:
  responses:
    ListManagedAccountsAllocatableGlobalOutboundChannelsResponse:
      description: >-
        Successful response with information about allocatable global outbound
        channels.
      content:
        application/json:
          schema:
            type: object
            properties:
              data:
                $ref: '#/components/schemas/ManagedAccountsGlobalOutboundChannels'
    managed-accounts_UnauthorizedResponse:
      description: >-
        Unauthenticated response. Happens when the current user cannot be
        authenticated.
    managed-accounts_ForbiddenResponse:
      description: >-
        Unauthorized response. Happens when the current user is not authorized
        to access the endpoint.
  schemas:
    ManagedAccountsGlobalOutboundChannels:
      title: Managed Accounts Global Outbound Channels
      properties:
        managed_account_allow_custom_pricing:
          type: boolean
          description: >-
            Boolean value that indicates if the managed account is able to have
            custom pricing set for it or not. If false, uses the pricing of the
            manager account. Defaults to false. This value may be changed, but
            there may be time lag between when the value is changed and pricing
            changes take effect.
          example: false
        allocatable_global_outbound_channels:
          type: integer
          description: >-
            The total amount of allocatable global outbound channels available
            to the authenticated manager. Will be 0 if the feature is not
            enabled for their account.
          example: 500
        record_type:
          type: string
          description: The type of the data contained in this record.
          example: allocatable_global_outbound_channels
        total_global_channels_allocated:
          type: integer
          description: >-
            The total number of allocatable global outbound channels currently
            allocated across all managed accounts for the authenticated user.
            This includes any amount of channels allocated by default at managed
            account creation time. Will be 0 if the feature is not enabled for
            their account.
          example: 135
      example:
        allocatable_global_outbound_channels: 500
        record_type: allocatable_global_outbound_channels
        total_global_channels_allocated: 135
      type: object
  securitySchemes:
    bearerAuth:
      scheme: bearer
      type: http

````