> ## Documentation Index
> Fetch the complete documentation index at: https://documentation.onesignal.com/llms.txt
> Use this file to discover all available pages before exploring further.
# View messages
> View the details for a collection of messages.
## Overview
The View messages API fetches data for up to 50 push, email, or SMS messages at a time. To fetch a single message, use the [View message](/reference/view-message) API. In most cases, use [Event Streams](/docs/en/event-streams) instead.
This API does not return Journey-sent messages. See [Journey analytics](/docs/en/journeys-analytics) for details.
Messages sent through the API are **retained for 30 days** after creation; messages sent through the OneSignal dashboard are retained for the app's lifetime.
See [Rate limits](/reference/rate-limits) for details on how often you can pull your message data with this API.
***
## How to use this API
Use time-offset pagination for sequential pulls of all messages, and standard pagination for ad-hoc queries. For ETL or bulk export pipelines, use [Event Streams](/docs/en/event-streams) instead.
Filter results to a specific message kind or template using the `kind` and `template_id` query parameters. Both filters work with either pagination style.
### Optimized pagination with time offset
To efficiently retrieve all available messages for an app, use `time_offset`-based pagination. When `time_offset` is specified, the sort order changes from descending to ascending — the oldest messages appear first based on the [`send_after` date](/reference/create-message#send-after).
#### Accepted `time_offset` values
* ISO 8601 formatted timestamp — for example, `2025-01-01T00:00:00.000Z` (January 1, 2025, at 00:00 UTC).
* Opaque cursor token (Base64-encoded) — provided in the API response as `next_time_offset`.
To fetch messages from a specific date onward, set `time_offset` to an ISO 8601 formatted timestamp. For example, to retrieve messages sent since January 1, 2025: `time_offset=2025-01-01T00:00:00.000Z`.
* `time_offset` cannot be used with the standard `offset` parameter.
* `time_offset` excludes messages that match the exact timestamp to avoid duplicates.
* The response includes `next_time_offset`, a cursor token for the next page. No decoding required. For example: `"next_time_offset": "MjAyNS0wMi0xOVQxOToxNjo0OS41Njg5NTFaIzQ2ZWVjMTAzLWQ5OGYtNGQzZC04MzA5LWQxNWI1M2QzMjQ5Nw=="`
Use `next_time_offset` from the previous response as the `time_offset` value in the next request. For example: `time_offset=MjAyNS0wMi0xOVQxOToxNjo0OS41Njg5NTFaIzQ2ZWVjMTAzLWQ5OGYtNGQzZC04MzA5LWQxNWI1M2QzMjQ5Nw==`.
Repeat the request until an empty `notifications` array is returned, indicating all messages have been fetched.
Because results are sorted ascending, new messages are added to the end. To resume fetching from where you left off, reuse the last `next_time_offset` that returned an empty response.
### Standard pagination
Use the `limit` and `offset` parameters to page through notifications for an app. The maximum result size is 50, and the default `limit` is `50`. Use `limit` to specify the result size and `offset` to increment by the limit value with each request.
For example, the first request uses `offset=0`, the second `offset=50`, the third `offset=100`, and so on.
Standard pagination is convenient for ad-hoc queries but degrades as the `offset` value grows. For sequential pulls of all messages, use time-offset pagination.
***
## OpenAPI
````yaml GET /notifications?app_id={app_id}&limit={limit}&offset={offset}&kind={kind}&template_id={template_id}&time_offset={time_offset}
openapi: 3.1.0
info:
title: api.onesignal.com
version: '11.6'
servers:
- url: https://api.onesignal.com
security:
- {}
paths:
/notifications?app_id={app_id}&limit={limit}&offset={offset}&kind={kind}&template_id={template_id}&time_offset={time_offset}:
get:
summary: View messages
description: View the details for a collection of messages.
operationId: view-messages
parameters:
- name: app_id
in: query
description: >-
Your OneSignal App ID in UUID v4 format. See [Keys &
IDs](/docs/en/keys-and-ids).
required: true
schema:
type: string
default: YOUR_APP_ID
- name: Authorization
in: header
description: >-
Your App API key with prefix `Key `. See [Keys &
IDs](/docs/en/keys-and-ids).
required: true
schema:
type: string
default: Key YOUR_APP_API_KEY
- name: limit
in: query
description: >-
Specifies the maximum number of messages to return in a single
query. The maximum and default is **50** messages per request.
schema:
type: integer
format: int32
- name: offset
in: query
description: >-
Controls the starting point for the notifications being returned.
Default is **0**. Results are returned and sorted in descending
order by `queued_at`.
schema:
type: integer
format: int32
- name: kind
in: query
description: >-
Specifies which push notifications to return based on how it was
created. Use this to segment push by their creation method, allowing
for targeted analysis or management of notification types. All push
types are returned by default. `0` - Notifications created through
the dashboard. `1` - Notifications sent via API calls. `3` -
Notifications triggered through automated systems.
schema:
type: integer
format: int32
- name: template_id
in: query
description: >-
The template ID in UUID v4 format set for the message if applicable.
See [Templates](/docs/en/templates).
schema:
type: string
- name: time_offset
in: query
description: >-
An ISO 8601 formatted timestamp or Base64 integer token (provided in
the API response). See [`time_offset` Accepted
Values](#time_offset-accepted-values).
schema:
type: string
responses:
'200':
description: '200'
content:
application/json:
schema:
type: object
description: >-
Returns all message properties for up to 50 messages per
request. See the [Push
notifications](/reference/push-notification),
[Email](/reference/email), and/or [SMS](/reference/sms)
Message Create APIs for all properties. Most commonly used
properties for this endpoint are listed.
properties:
total_count:
type: integer
description: >-
The total number of messages available in the dashboard
irrespective of page
time_offset:
type: string
description: The `time_offset` if specified in the request.
next_time_offset:
type: string
description: >-
A Base64-encoded cursor token representing the next group
of messages to fetch if `time_offset` provided.
offset:
type: integer
description: >-
The offset specified. Defaults to `0` if not provided in
the request.
limit:
type: integer
description: >-
The `limit` specified. Defaults to `50` if not provided in
the request.
notifications:
type: array
description: >-
An array of message objects. `notifications: []` indicates
no more messages to fetch. The data provided is generally
the most desired from this request
items:
type: object
properties:
app_id:
type: string
description: >-
Your OneSignal App ID in UUID v4 format. See [Keys &
IDs](/docs/en/keys-and-ids).
big_picture:
description: The URL of the image set in the push notification.
type: string
canceled:
description: Whether the message was canceled.
type: boolean
chrome_web_icon:
description: The URL of the icon set in the push notification.
type: string
chrome_web_image:
description: The URL of the image set in the push notification.
type: string
name:
type: string
description: >-
An internal name you set to help organize and track
messages. Not shown to recipients. Maximum 128
characters.
contents:
description: >-
The main message body with [language-specific
values](/docs/en/multi-language-messaging#supported-languages).
type: object
properties:
en:
type: string
description: >-
The required message language type. See
[Supported
Languages](/docs/en/multi-language-messaging#supported-languages).
converted:
type: integer
description: The number of times the push was clicked.
data:
type: object
description: >-
The JSON data set in the push notification if
applicable.
delayed_option:
type: string
description: The per-user delay option set for the message.
delivery_time_of_day:
type: string
description: >-
The delivery time of day set for the message if
`delayed_option` is `timezone`.
remaining:
type: integer
description: >-
The number of messages that have not been sent yet.
If `null`, then the system is still processing the
audience, try again later.
errored:
type: integer
description: The number of times the message errored.
excluded_segments:
type: array
description: >-
The segments excluded from the message if
applicable.
failed:
type: integer
description: >-
The number of subscriptions reported unsubscribed
for the message.
global_image:
description: The URL of the image set in the push notification.
type: string
headings:
type: object
description: The title of the push notification.
id:
type: string
description: The identifier of the message in UUID v4 format.
included_segments:
type: array
description: The segments included in the message if applicable.
ios_badgeCount:
type: integer
description: The badge count set for the message if applicable.
ios_badgeType:
type: string
description: The badge type set for the message if applicable.
queued_at:
type: integer
description: Unix timestamp of when the message was created.
send_after:
type: integer
description: >-
Unix timestamp of when the message delivery was
scheduled to begin.
completed_at:
type: integer
description: >-
Unix timestamp of when the message delivery was
completed. The delivery duration from start to
finish can be calculated with `completed_at -
send_after`.
successful:
type: integer
description: >-
The number of messages successfully delivered to the
push, email, or SMS servers.
received:
type: integer
description: >-
The number of messages that confirmed being received
aka [Confirmed
Deliveries](/docs/confirmed-delivery).
filters:
type: object
description: The filters set for the message if applicable.
template_id:
type: string
description: >-
The template ID in UUID v4 format set for the
message if applicable. See
[Templates](/docs/en/templates).
url:
type: string
description: The URL of the push notification.
web_url:
type: string
description: >-
The URL of the push notification for web push
subscriptions.
app_url:
type: string
description: >-
The URL of the push notification for mobile
subscriptions.
platform_delivery_stats:
type: object
description: >-
The successful, errored, failed, converted, received
and frequency cap counts for each platform
applicable.
throttle_rate_per_minute:
type: number
description: >-
The throttle rate of the push notification if
applicable.
fcap_status:
type: string
description: >-
The frequency cap status of the push notification if
applicable.
outcomes:
type: object
description: >-
The id, value, and aggregation type of the outcome
set in the request.
'429':
description: >-
Rate limit exceeded. Wait the number of seconds in the `Retry-After`
header before retrying.
headers:
Retry-After:
description: >-
Number of seconds to wait before retrying the request. Always
emitted on 429 responses.
schema:
type: integer
minimum: 0
content:
application/json:
schema:
$ref: '#/components/schemas/BasicErrorResponse'
example:
errors:
- API rate limit exceeded
'503':
description: >-
Service temporarily unavailable. Retry after a short backoff. The
body may be empty or non-JSON in some failure modes.
headers:
Retry-After:
description: >-
Number of seconds to wait before retrying. Optional — may be
absent when the response is generated upstream.
schema:
type: integer
minimum: 0
content:
application/json:
schema:
$ref: '#/components/schemas/BasicErrorResponse'
example:
errors:
- Service temporarily unavailable
deprecated: false
x-codeSamples:
- lang: typescript
label: Node.js SDK
source: >-
import Onesignal from '@onesignal/node-onesignal';
const configuration = Onesignal.createConfiguration({
restApiKey: 'YOUR_REST_API_KEY',
});
const apiInstance = new Onesignal.DefaultApi(configuration);
// string | The app ID that you want to view notifications from
const appId: string = "00000000-0000-0000-0000-000000000000";
// number | How many notifications to return. Max is 50. Default
is 50. (optional)
const limit: number = 10;
// number | Page offset. Default is 0. Results are sorted by
queued_at in descending order. queued_at is a representation of the
time that the notification was queued at. (optional)
const offset: number = 0;
// 0 | 1 | 3 | Kind of notifications returned: * unset - All
notification types (default) * `0` - Dashboard only * `1` - API
only * `3` - Automated only (optional)
const kind: 0 | 1 | 3 = 0;
// string | Time-offset pagination cursor for sequential pulls of
all messages. Accepts either an ISO 8601 formatted timestamp (e.g.
`2025-01-01T00:00:00.000Z`) or the opaque Base64 cursor token
returned as `next_time_offset` in a prior response. When set,
results are sorted ascending by send_after and the standard `offset`
parameter cannot be used. Repeat the request with each
`next_time_offset` until an empty notifications array is returned.
(optional)
const timeOffset: string = "2025-01-01T00:00:00.000Z";
try {
const response = await apiInstance.getNotifications(appId, limit, offset, kind, timeOffset);
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("getNotifications failed: HTTP " + e.code, e.errorMessages);
} else {
throw e;
}
}
- lang: python
label: Python SDK
source: >-
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" # The app ID that you want to view notifications from
limit = 10 # How many notifications to return. Max is 50. Default is 50. (optional)
offset = 0 # Page offset. Default is 0. Results are sorted by queued_at in descending order. queued_at is a representation of the time that the notification was queued at. (optional)
kind = 0 # Kind of notifications returned: * unset - All notification types (default) * `0` - Dashboard only * `1` - API only * `3` - Automated only (optional)
time_offset = "2025-01-01T00:00:00.000Z" # Time-offset pagination cursor for sequential pulls of all messages. Accepts either an ISO 8601 formatted timestamp (e.g. `2025-01-01T00:00:00.000Z`) or the opaque Base64 cursor token returned as `next_time_offset` in a prior response. When set, results are sorted ascending by send_after and the standard `offset` parameter cannot be used. Repeat the request with each `next_time_offset` until an empty notifications array is returned. (optional)
try:
# View notifications
api_response = api_instance.get_notifications(app_id, limit=limit, offset=offset, kind=kind, time_offset=time_offset)
pprint(api_response)
except onesignal.ApiException as e:
print("Exception when calling DefaultApi->get_notifications: %s\n" % e)
print("Status Code: %s" % e.status)
print("Response Body: %s" % e.body)
- lang: php
label: PHP SDK
source: >-
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 | The
app ID that you want to view notifications from
$limit = 10; // int | How many notifications to return. Max is 50.
Default is 50.
$offset = 0; // int | Page offset. Default is 0. Results are
sorted by queued_at in descending order. queued_at is a
representation of the time that the notification was queued at.
$kind = 0; // int | Kind of notifications returned: * unset - All
notification types (default) * `0` - Dashboard only * `1` - API
only * `3` - Automated only
$time_offset = '2025-01-01T00:00:00.000Z'; // string | Time-offset
pagination cursor for sequential pulls of all messages. Accepts
either an ISO 8601 formatted timestamp (e.g.
`2025-01-01T00:00:00.000Z`) or the opaque Base64 cursor token
returned as `next_time_offset` in a prior response. When set,
results are sorted ascending by send_after and the standard `offset`
parameter cannot be used. Repeat the request with each
`next_time_offset` until an empty notifications array is returned.
try {
$result = $apiInstance->getNotifications($app_id, $limit, $offset, $kind, $time_offset);
print_r($result);
} catch (\onesignal\client\ApiException $e) {
echo 'Exception when calling DefaultApi->getNotifications: ', $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->getNotifications: ', $e->getMessage(), PHP_EOL;
}
- lang: go
label: Go SDK
source: |-
package main
import (
"context"
"fmt"
"os"
"github.com/OneSignal/onesignal-go-api/v5"
)
func main() {
appId := "00000000-0000-0000-0000-000000000000" // string | The app ID that you want to view notifications from
limit := int32(10) // int32 | How many notifications to return. Max is 50. Default is 50. (optional)
offset := int32(0) // int32 | Page offset. Default is 0. Results are sorted by queued_at in descending order. queued_at is a representation of the time that the notification was queued at. (optional)
kind := int32(0) // int32 | Kind of notifications returned: * unset - All notification types (default) * `0` - Dashboard only * `1` - API only * `3` - Automated only (optional)
timeOffset := "2025-01-01T00:00:00.000Z" // string | Time-offset pagination cursor for sequential pulls of all messages. Accepts either an ISO 8601 formatted timestamp (e.g. `2025-01-01T00:00:00.000Z`) or the opaque Base64 cursor token returned as `next_time_offset` in a prior response. When set, results are sorted ascending by send_after and the standard `offset` parameter cannot be used. Repeat the request with each `next_time_offset` until an empty notifications array is returned. (optional)
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.GetNotifications(restAuth).AppId(appId).Limit(limit).Offset(offset).Kind(kind).TimeOffset(timeOffset).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `DefaultApi.GetNotifications``: %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 `GetNotifications`: NotificationSlice
fmt.Fprintf(os.Stdout, "Response from `DefaultApi.GetNotifications`: %v\n", resp)
}
- lang: ruby
label: Ruby SDK
source: >-
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 | The app
ID that you want to view notifications from
opts = {
limit: 10, # Integer | How many notifications to return. Max is 50. Default is 50.
offset: 0, # Integer | Page offset. Default is 0. Results are sorted by queued_at in descending order. queued_at is a representation of the time that the notification was queued at.
kind: 0, # Integer | Kind of notifications returned: * unset - All notification types (default) * `0` - Dashboard only * `1` - API only * `3` - Automated only
time_offset: '2025-01-01T00:00:00.000Z' # String | Time-offset pagination cursor for sequential pulls of all messages. Accepts either an ISO 8601 formatted timestamp (e.g. `2025-01-01T00:00:00.000Z`) or the opaque Base64 cursor token returned as `next_time_offset` in a prior response. When set, results are sorted ascending by send_after and the standard `offset` parameter cannot be used. Repeat the request with each `next_time_offset` until an empty notifications array is returned.
}
begin
# View notifications
result = api_instance.get_notifications(app_id, opts)
p result
rescue OneSignal::ApiError => e
puts "Error when calling DefaultApi->get_notifications: #{e}"
puts "Status Code: #{e.code}"
# `e.error_messages` flattens any error-envelope shape to an Array;
# the raw body remains on `e.response_body`.
puts "Error Messages: #{e.error_messages}"
puts "Response Body: #{e.response_body}"
end
- lang: java
label: Java SDK
source: |-
// 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 | The app ID that you want to view notifications from
Integer limit = 10; // Integer | How many notifications to return. Max is 50. Default is 50.
Integer offset = 0; // Integer | Page offset. Default is 0. Results are sorted by queued_at in descending order. queued_at is a representation of the time that the notification was queued at.
Integer kind = 0; // Integer | Kind of notifications returned: * unset - All notification types (default) * `0` - Dashboard only * `1` - API only * `3` - Automated only
String timeOffset = "2025-01-01T00:00:00.000Z"; // String | Time-offset pagination cursor for sequential pulls of all messages. Accepts either an ISO 8601 formatted timestamp (e.g. `2025-01-01T00:00:00.000Z`) or the opaque Base64 cursor token returned as `next_time_offset` in a prior response. When set, results are sorted ascending by send_after and the standard `offset` parameter cannot be used. Repeat the request with each `next_time_offset` until an empty notifications array is returned.
try {
NotificationSlice result = apiInstance.getNotifications(appId, limit, offset, kind, timeOffset);
System.out.println(result);
} catch (ApiException e) {
System.err.println("Exception when calling DefaultApi#getNotifications");
System.err.println("Status code: " + e.getCode());
// getErrorMessages() flattens any error-envelope shape to a List;
// 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();
}
}
}
- lang: csharp
label: C# SDK
source: |-
using System;
using System.Collections.Generic;
using System.Diagnostics;
using OneSignalApi.Api;
using OneSignalApi.Client;
using OneSignalApi.Model;
namespace Example
{
public class GetNotificationsExample
{
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 | The app ID that you want to view notifications from
var limit = 10; // int? | How many notifications to return. Max is 50. Default is 50. (optional)
var offset = 0; // int? | Page offset. Default is 0. Results are sorted by queued_at in descending order. queued_at is a representation of the time that the notification was queued at. (optional)
var kind = 0; // int? | Kind of notifications returned: * unset - All notification types (default) * `0` - Dashboard only * `1` - API only * `3` - Automated only (optional)
var timeOffset = "2025-01-01T00:00:00.000Z"; // string | Time-offset pagination cursor for sequential pulls of all messages. Accepts either an ISO 8601 formatted timestamp (e.g. `2025-01-01T00:00:00.000Z`) or the opaque Base64 cursor token returned as `next_time_offset` in a prior response. When set, results are sorted ascending by send_after and the standard `offset` parameter cannot be used. Repeat the request with each `next_time_offset` until an empty notifications array is returned. (optional)
try
{
// View notifications
NotificationSlice result = apiInstance.GetNotifications(appId, limit, offset, kind, timeOffset);
Debug.WriteLine(result);
}
catch (ApiException e)
{
Debug.Print("Exception when calling DefaultApi.GetNotifications: " + e.Message );
Debug.Print("Status Code: "+ e.ErrorCode);
// e.ErrorMessages flattens any error-envelope shape to an IReadOnlyList;
// 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);
}
}
}
}
- lang: rust
label: Rust SDK
source: |-
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";
let limit: Option = None;
let offset: Option = None;
let kind: Option = None;
let time_offset: Option<&str> = None;
match default_api::get_notifications(&configuration, app_id, limit, offset, kind, time_offset).await {
Ok(resp) => println!("{:?}", resp),
Err(e @ onesignal_rust_api::apis::Error::ResponseError(_)) => {
// `e.error_messages()` flattens any error-envelope shape to a Vec;
// the raw response remains on the ResponseError variant.
eprintln!("get_notifications failed: {:?}", e.error_messages());
}
Err(e) => eprintln!("get_notifications failed: {:?}", e),
}
}
components:
schemas:
BasicErrorResponse:
type: object
properties:
errors:
type: array
items:
type: string
description: One or more human-readable error messages.
success:
type: boolean
description: >-
Present (and `false`) on some endpoints (notifications, templates,
segments). Not emitted by every endpoint.
reference:
type: array
items:
type: string
description: >-
Documentation URL fragments related to the error. Only emitted by
the API-key auth error helpers.
````