View an app

View the details of a single OneSignal app

GET /apps/{app_id}

cURL

cURL

curl --request GET \
  --url https://api.onesignal.com/apps/{app_id} \
  --header 'Authorization: <authorization>' \
  --header 'Content-Type: <content-type>'

import Onesignal from '@onesignal/node-onesignal';

const configuration = Onesignal.createConfiguration({
    restApiKey: 'YOUR_REST_API_KEY',
});
const apiInstance = new Onesignal.DefaultApi(configuration);

// string | An app id
const appId: string = "00000000-0000-0000-0000-000000000000";

try {
  const response = await apiInstance.getApp(appId);
  console.log(response);
} catch (e) {
  if (e instanceof Onesignal.ApiException) {
    // `e.errorMessages` flattens any error-envelope shape to a `string[]`;
    // the raw parsed body remains on `e.body`.
    console.error("getApp failed: HTTP " + e.code, e.errorMessages);
  } else {
    throw e;
  }
}

import onesignal
from onesignal.api import default_api
from onesignal.models import *
from pprint import pprint

# See configuration.py for a list of all supported configuration parameters.
# Some of the OneSignal endpoints require ORGANIZATION_API_KEY token for authorization, while others require REST_API_KEY.
# We recommend adding both of them in the configuration page so that you will not need to figure it out yourself.
configuration = onesignal.Configuration(
    rest_api_key = "YOUR_REST_API_KEY", # App REST API key required for most endpoints
    organization_api_key = "YOUR_ORGANIZATION_API_KEY" # Organization key is only required for creating new apps and other top-level endpoints
)


# Enter a context with an instance of the API client
with onesignal.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = default_api.DefaultApi(api_client)
    app_id = "00000000-0000-0000-0000-000000000000" # An app id 

    try:
        # View an app
        api_response = api_instance.get_app(app_id)
        pprint(api_response)
    except onesignal.ApiException as e:
        print("Exception when calling DefaultApi->get_app: %s\n" % e)
        print("Status Code: %s" % e.status)
        print("Response Body: %s" % e.body)

<?php
require_once(__DIR__ . '/vendor/autoload.php');


// Configure Bearer authorization: rest_api_key
$config = onesignal\client\Configuration::getDefaultConfiguration()
                                                ->setRestApiKeyToken('YOUR_REST_API_KEY')
                                                ->setOrganizationApiKeyToken('YOUR_ORGANIZATION_API_KEY');



$apiInstance = new onesignal\client\Api\DefaultApi(
    // If you want use custom http client, pass your client which implements `GuzzleHttp\ClientInterface`.
    // This is optional, `GuzzleHttp\Client` will be used as default.
    new GuzzleHttp\Client(),
    $config
);
$app_id = '00000000-0000-0000-0000-000000000000'; // string | An app id

try {
    $result = $apiInstance->getApp($app_id);
    print_r($result);
} catch (\onesignal\client\ApiException $e) {
    echo 'Exception when calling DefaultApi->getApp: ', $e->getMessage(), PHP_EOL;
    echo 'Status Code: ', $e->getCode(), PHP_EOL;
    // getErrorMessages() flattens any error-envelope shape to a string[];
    // the raw body remains on getResponseBody().
    echo 'Error Messages: ', implode(', ', $e->getErrorMessages()), PHP_EOL;
    echo 'Response Body: ', $e->getResponseBody(), PHP_EOL;
} catch (\Exception $e) {
    echo 'Exception when calling DefaultApi->getApp: ', $e->getMessage(), PHP_EOL;
}

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/OneSignal/onesignal-go-api/v5"
)

func main() {
    appId := "00000000-0000-0000-0000-000000000000" // string | An app id

    configuration := onesignal.NewConfiguration()
    apiClient := onesignal.NewAPIClient(configuration)

    restAuth := context.WithValue(context.Background(), onesignal.RestApiKey, "YOUR_REST_API_KEY") // App REST API key required for most endpoints

    resp, r, err := apiClient.DefaultApi.GetApp(restAuth, appId).Execute()

    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultApi.GetApp``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
        if apiErr, ok := err.(*onesignal.GenericOpenAPIError); ok {
            // ErrorMessages() flattens any error-envelope shape to a []string;
            // the raw body remains on Body().
            fmt.Fprintf(os.Stderr, "Error Messages: %v\n", apiErr.ErrorMessages())
            fmt.Fprintf(os.Stderr, "Response Body: %s\n", apiErr.Body())
        }
    }
    // response from `GetApp`: App
    fmt.Fprintf(os.Stdout, "Response from `DefaultApi.GetApp`: %v\n", resp)
}

require 'onesignal'
# setup authorization
OneSignal.configure do |config|
  # Configure Bearer authorization: rest_api_key
  config.rest_api_key = 'YOUR_REST_API_KEY'

end

api_instance = OneSignal::DefaultApi.new
app_id = '00000000-0000-0000-0000-000000000000' # String | An app id

begin
  # View an app
  result = api_instance.get_app(app_id)
  p result
rescue OneSignal::ApiError => e
  puts "Error when calling DefaultApi->get_app: #{e}"
  puts "Status Code: #{e.code}"
  # `e.error_messages` flattens any error-envelope shape to an Array<String>;
  # the raw body remains on `e.response_body`.
  puts "Error Messages: #{e.error_messages}"
  puts "Response Body: #{e.response_body}"
end

// Import classes:
import com.onesignal.client.ApiClient;
import com.onesignal.client.ApiException;
import com.onesignal.client.Configuration;
import com.onesignal.client.auth.*;
import com.onesignal.client.model.*;
import com.onesignal.client.api.DefaultApi;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = Configuration.getDefaultApiClient();
    defaultClient.setBasePath("https://api.onesignal.com");
    
    // Configure HTTP bearer authorization: rest_api_key
    HttpBearerAuth rest_api_key = (HttpBearerAuth) defaultClient.getAuthentication("rest_api_key");
    rest_api_key.setBearerToken("YOUR_REST_API_KEY");

    DefaultApi apiInstance = new DefaultApi(defaultClient);
    String appId = "00000000-0000-0000-0000-000000000000"; // String | An app id
    try {
      App result = apiInstance.getApp(appId);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling DefaultApi#getApp");
      System.err.println("Status code: " + e.getCode());
      // getErrorMessages() flattens any error-envelope shape to a List<String>;
      // the raw body remains on getResponseBody().
      System.err.println("Error messages: " + e.getErrorMessages());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using OneSignalApi.Api;
using OneSignalApi.Client;
using OneSignalApi.Model;

namespace Example
{
    public class GetAppExample
    {
        public static void Main()
        {
            Configuration config = new Configuration();
            config.BasePath = "https://api.onesignal.com";
            // Configure Bearer token for authorization: rest_api_key
            config.AccessToken = "YOUR_REST_API_KEY";

            var apiInstance = new DefaultApi(config);
            var appId = "00000000-0000-0000-0000-000000000000";  // string | An app id

            try
            {
                // View an app
                App result = apiInstance.GetApp(appId);
                Debug.WriteLine(result);
            }
            catch (ApiException  e)
            {
                Debug.Print("Exception when calling DefaultApi.GetApp: " + e.Message );
                Debug.Print("Status Code: "+ e.ErrorCode);
                // e.ErrorMessages flattens any error-envelope shape to an IReadOnlyList<string>;
                // the raw body remains on e.ErrorContent.
                Debug.Print("Error Messages: " + string.Join(", ", e.ErrorMessages));
                Debug.Print("Response Body: " + e.ErrorContent);
                Debug.Print(e.StackTrace);
            }
        }
    }
}

use onesignal_rust_api::apis::configuration::Configuration;
use onesignal_rust_api::apis::default_api;


#[tokio::main]
async fn main() {
    let mut configuration = Configuration::new();
    configuration.rest_api_key_token = Some("YOUR_REST_API_KEY".to_string());


    // Realistic values are pulled from the spec's `example:` fields where present.
    let app_id: &str = "00000000-0000-0000-0000-000000000000";

    match default_api::get_app(&configuration, app_id).await {
        Ok(resp) => println!("{:?}", resp),
        Err(e @ onesignal_rust_api::apis::Error::ResponseError(_)) => {
            // `e.error_messages()` flattens any error-envelope shape to a Vec<String>;
            // the raw response remains on the ResponseError variant.
            eprintln!("get_app failed: {:?}", e.error_messages());
        }
        Err(e) => eprintln!("get_app failed: {:?}", e),
    }
}

200

{
  "id": "<string>",
  "name": "<string>",
  "players": 123,
  "messageable_players": 123,
  "created_at": "<string>",
  "updated_at": "<string>",
  "organization_id": "<string>",
  "additional_data_is_root_payload": true,
  "gcm_key": "<string>",
  "fcm_v1_service_account_json": "<string>",
  "fcm_sender_id": "<string>",
  "chrome_key": "<string>",
  "chrome_web_key": "<string>",
  "chrome_web_origin": "<string>",
  "chrome_web_gcm_sender_id": "<string>",
  "chrome_web_default_notification_icon": "<string>",
  "chrome_web_sub_domain": "<string>",
  "apns_env": "<string>",
  "apns_certificates": "<string>",
  "apns_p8": "<string>",
  "apns_team_id": "<string>",
  "apns_key_id": "<string>",
  "apns_bundle_id": "<string>",
  "safari_apns_certificate": "<string>",
  "safari_site_origin": "<string>",
  "safari_push_id": "<string>",
  "safari_icon_16_16": "<string>",
  "safari_icon_32_32": "<string>",
  "safari_icon_64_64": "<string>",
  "safari_icon_128_128": "<string>",
  "safari_icon_256_256": "<string>",
  "site_name": "<string>",
  "conversion_attribution_window_push": 123,
  "conversion_attribution_window_iam": 123,
  "conversion_attribution_window_email": 123,
  "conversion_attribution_window_sms": 123,
  "channels": {}
}

{
  "errors": [
    "You do not have permission to view this app."
  ]
}

{
  "errors": [
    "Couldn't find app with id = <app_id>"
  ]
}

{
  "errors": [
    "API rate limit exceeded"
  ]
}

{
  "errors": [
    "Service temporarily unavailable"
  ]
}

Overview

Use this API to retrieve metadata and platform configuration for a single OneSignal app associated with your account. This includes app names, App ID, Subscription counts, timestamps, and push platform credentials (Android/FCM, iOS/APNs, Web Push, Safari), making it easy to programmatically manage or audit your applications.

This API does not return the app’s API keys. To manage API keys, use the Create API Key, Rotate API Key, and Delete API Key APIs.

---

How to use this API

To retrieve your app, send a GET request to the /apps/{app_id} endpoint using your App API Key. This key can be found in your OneSignal dashboard under Settings > Keys & IDs.

Pass ?view=config to return configuration-only data. This omits the players and messageable_players subscription counts and skips the count lookup, returning a faster response when you only need platform configuration.

---

Headers

Content-Type · string · default: application/json · required

Authorization · string · default: Key YOUR_APP_API_KEY · required

Your App API key with prefix Key. See Keys & IDs.

Path Parameters

app_id · string · required

Your OneSignal App ID in UUID v4 format. See Keys & IDs.

Query Parameters

view · enum<string>

Set to config to return configuration-only data. This omits players and messageable_players, skipping the subscription-count lookup for a faster response.

Available options: config

Response

200

application/json

200

id · string

The OneSignal App ID in UUID v4 format.

name · string

An internal name you set to help organize and track Apps. Maximum 128 characters.

players · integer

The total number of Subscriptions in the app. Omitted when view=config is passed.

messageable_players · integer

The number of Subscriptions eligible to receive messages in the app. Omitted when view=config is passed.

created_at · string

The date and time the app was created.

updated_at · string

The date and time the app was last updated.

organization_id · string

The Organization ID in which the app was created.

additional_data_is_root_payload · boolean

When true, custom additional data is sent at the root of the push payload instead of nested under a custom key (iOS only).

gcm_key · string

Legacy. The deprecated Google Cloud Messaging (GCM/FCM legacy) server API key. Retained for backward compatibility; use fcm_v1_service_account_json instead.

fcm_v1_service_account_json · string

Your FCM Service Account JSON file for Android push notifications. See Android: Firebase Credentials.

fcm_sender_id · string

The FCM Sender ID associated with your Firebase project.

chrome_key · string

Legacy. The deprecated Google Chrome extension (GCM) API key. Retained for backward compatibility.

chrome_web_key · string

Web push VAPID public key for Chrome web push notifications.

chrome_web_origin · string

The HTTPS origin URL for your website. Required for web push notifications.

chrome_web_gcm_sender_id · string

The GCM Sender ID used for web push notifications.

chrome_web_default_notification_icon · string

The full HTTPS URL to your default notification icon. Should be a 256x256px PNG.

chrome_web_sub_domain · string

The OneSignal subdomain for web push if not using your own origin.

apns_env · string

The APNS environment: production or development. See iOS SDK Setup.

apns_certificates · string

The APNS p12 certificate for iOS push notifications.

apns_p8 · string

The APNs Auth Key (.p8) token-based credential for iOS push notifications.

apns_team_id · string

The Apple Developer Team ID associated with the APNs Auth Key.

apns_key_id · string

The Key ID of the APNs Auth Key (.p8).

apns_bundle_id · string

The app bundle ID associated with the APNs Auth Key.

safari_apns_certificate · string

The Safari APNs certificate, or "OneSignal Provided Certificate" when using a OneSignal-managed Safari certificate.

safari_site_origin · string

The HTTPS origin URL configured for Safari web push.

safari_push_id · string

The Safari Web Push ID (website push ID / certificate bundle ID).

safari_icon_16_16 · string

URL to the 16x16px Safari notification icon.

safari_icon_32_32 · string

URL to the 32x32px Safari notification icon.

safari_icon_64_64 · string

URL to the 64x64px Safari notification icon.

safari_icon_128_128 · string

URL to the 128x128px Safari notification icon.

safari_icon_256_256 · string

URL to the 256x256px Safari notification icon.

site_name · string

The name of the website configured for web push.

conversion_attribution_window_push · integer

Conversion (outcome) attribution window for push, in minutes.

conversion_attribution_window_iam · integer

Conversion (outcome) attribution window for in-app messages, in minutes.

conversion_attribution_window_email · integer

Conversion (outcome) attribution window for email, in minutes.

conversion_attribution_window_sms · integer

Conversion (outcome) attribution window for SMS, in minutes.

channels · object

Messaging channels available for this app, keyed by channel name. Each entry indicates whether the channel is enabled and which platforms are configured for it.

Show child attributes