--- title: Create On-Call schedule description: Datadog, the leading service for cloud-scale monitoring. breadcrumbs: Docs > API Reference > On-Call --- {% callout %} # Important note for users on the following Datadog sites: app.ddog-gov.com, us2.ddog-gov.com {% alert level="danger" %} This product is not supported for your selected [Datadog site](https://docs.datadoghq.com/getting_started/site.md). ({% placeholder "user-datadog-site-name" /%}). {% /alert %} {% /callout %} # Create On-Call schedule{% #create-on-call-schedule %} {% tab title="v2" %} | Datadog site | API endpoint | | ----------------- | ----------------------------------------------------------- | | ap1.datadoghq.com | POST https://api.ap1.datadoghq.com/api/v2/on-call/schedules | | ap2.datadoghq.com | POST https://api.ap2.datadoghq.com/api/v2/on-call/schedules | | app.datadoghq.eu | POST https://api.datadoghq.eu/api/v2/on-call/schedules | | app.ddog-gov.com | POST https://api.ddog-gov.com/api/v2/on-call/schedules | | us2.ddog-gov.com | POST https://api.us2.ddog-gov.com/api/v2/on-call/schedules | | app.datadoghq.com | POST https://api.datadoghq.com/api/v2/on-call/schedules | | us3.datadoghq.com | POST https://api.us3.datadoghq.com/api/v2/on-call/schedules | | us5.datadoghq.com | POST https://api.us5.datadoghq.com/api/v2/on-call/schedules | ### Overview Create a new On-Call schedule This endpoint requires the `on_call_write` permission. ### Arguments #### Query Strings | Name | Type | Description | | ------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------ | | include | string | Comma-separated list of included relationships to be returned. Allowed values: `teams`, `layers`, `layers.members`, `layers.members.user`. | ### Request #### Body Data (required) {% tab title="Model" %} | Parent field | Field | Type | Description | | ------------- | -------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------- | | | data [*required*] | object | The core data wrapper for creating a schedule, encompassing attributes, relationships, and the resource type. | | data | attributes [*required*] | object | Describes the main attributes for creating a new schedule, including name, layers, and time zone. | | attributes | layers [*required*] | [object] | The layers of On-Call coverage that define rotation intervals and restrictions. | | layers | effective_date [*required*] | date-time | The date/time when this layer becomes active (in ISO 8601). | | layers | end_date | date-time | The date/time after which this layer no longer applies (in ISO 8601). | | layers | interval [*required*] | object | Defines how often the rotation repeats, using a combination of days and optional seconds. Should be at least 1 hour. | | interval | days | int32 | The number of days in each rotation cycle. | | interval | seconds | int64 | Any additional seconds for the rotation cycle (up to 30 days). | | layers | members [*required*] | [object] | A list of members who participate in this layer's rotation. | | members | user | object | Identifies the user participating in this layer as a single object with an `id`. | | user | id | string | The user's ID. | | layers | name [*required*] | string | The name of this layer. | | layers | restrictions | [object] | Zero or more time-based restrictions (for example, only weekdays, during business hours). | | restrictions | end_day | enum | A day of the week. Allowed enum values: `monday,tuesday,wednesday,thursday,friday,saturday,sunday` | | restrictions | end_time | string | Specifies the ending time for this restriction. | | restrictions | start_day | enum | A day of the week. Allowed enum values: `monday,tuesday,wednesday,thursday,friday,saturday,sunday` | | restrictions | start_time | string | Specifies the starting time for this restriction. | | layers | rotation_start [*required*] | date-time | The date/time when the rotation for this layer starts (in ISO 8601). | | layers | time_zone | string | The time zone for this layer. | | attributes | name [*required*] | string | A human-readable name for the new schedule. | | attributes | time_zone [*required*] | string | The time zone in which the schedule is defined. | | data | relationships | object | Gathers relationship objects for the schedule creation request, including the teams to associate. | | relationships | teams | object | Associates teams with this schedule in a data structure. | | teams | data | [object] | An array of team references for this schedule. | | data | id [*required*] | string | The unique identifier of the team in this relationship. | | data | type [*required*] | enum | Teams resource type. Allowed enum values: `teams` | | data | type [*required*] | enum | Schedules resource type. Allowed enum values: `schedules` | {% /tab %} {% tab title="Example" %} ```json { "data": { "attributes": { "layers": [ { "effective_date": "2021-11-01T11:11:11+00:00", "end_date": "2021-11-21T11:11:11+00:00", "interval": { "days": 1 }, "members": [ { "user": { "id": "string" } } ], "name": "Layer 1", "restrictions": [ { "end_day": "friday", "end_time": "17:00:00", "start_day": "monday", "start_time": "09:00:00" } ], "rotation_start": "2021-11-06T11:11:11+00:00" } ], "name": "Example-On-Call", "time_zone": "America/New_York" }, "relationships": { "teams": { "data": [ { "id": "aeadc05e-98a8-11ec-ac2c-da7ad0900001", "type": "teams" } ] } }, "type": "schedules" } } ``` {% /tab %} ### Response {% tab title="201" %} Created {% tab title="Model" %} Top-level container for a schedule object, including both the `data` payload and any related `included` resources (such as teams, layers, or members). | Parent field | Field | Type | Description | | ------------- | ---------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------- | | | data | object | Represents the primary data object for a schedule, linking attributes and relationships. | | data | attributes | object | Provides core properties of a schedule object such as its name and time zone. | | attributes | name | string | A short name for the schedule. | | attributes | time_zone | string | The time zone in which this schedule operates. | | data | id | string | The schedule's unique identifier. | | data | relationships | object | Groups the relationships for a schedule object, referencing layers and teams. | | relationships | layers | object | Associates layers with this schedule in a data structure. | | layers | data | [object] | An array of layer references for this schedule. | | data | id [*required*] | string | The unique identifier of the layer in this relationship. | | data | type [*required*] | enum | Layers resource type. Allowed enum values: `layers` | | relationships | teams | object | Associates teams with this schedule in a data structure. | | teams | data | [object] | An array of team references for this schedule. | | data | id [*required*] | string | The unique identifier of the team in this relationship. | | data | type [*required*] | enum | Teams resource type. Allowed enum values: `teams` | | data | type [*required*] | enum | Schedules resource type. Allowed enum values: `schedules` | | | included | [ ] | Any additional resources related to this schedule, such as teams and layers. | | included | Option 1 | object | Provides a reference to a team, including ID, type, and basic attributes/relationships. | | Option 1 | attributes | object | Encapsulates the basic attributes of a Team reference, such as name, handle, and an optional avatar or description. | | attributes | avatar | string | URL or reference for the team's avatar (if available). | | attributes | description | string | A short text describing the team. | | attributes | handle | string | A unique handle/slug for the team. | | attributes | name | string | The full, human-readable name of the team. | | Option 1 | id | string | The team's unique identifier. | | Option 1 | type [*required*] | enum | Teams resource type. Allowed enum values: `teams` | | included | Option 2 | object | Encapsulates a layer resource, holding attributes like rotation details, plus relationships to the members covering that layer. | | Option 2 | attributes | object | Describes key properties of a Layer, including rotation details, name, start/end times, and any restrictions. | | attributes | effective_date | date-time | When the layer becomes active (ISO 8601). | | attributes | end_date | date-time | When the layer ceases to be active (ISO 8601). | | attributes | interval | object | Defines how often the rotation repeats, using a combination of days and optional seconds. Should be at least 1 hour. | | interval | days | int32 | The number of days in each rotation cycle. | | interval | seconds | int64 | Any additional seconds for the rotation cycle (up to 30 days). | | attributes | name | string | The name of this layer. | | attributes | restrictions | [object] | An optional list of time restrictions for when this layer is in effect. | | restrictions | end_day | enum | A day of the week. Allowed enum values: `monday,tuesday,wednesday,thursday,friday,saturday,sunday` | | restrictions | end_time | string | Specifies the ending time for this restriction. | | restrictions | start_day | enum | A day of the week. Allowed enum values: `monday,tuesday,wednesday,thursday,friday,saturday,sunday` | | restrictions | start_time | string | Specifies the starting time for this restriction. | | attributes | rotation_start | date-time | The date/time when the rotation starts (ISO 8601). | | attributes | time_zone | string | The time zone for this layer. | | Option 2 | id | string | A unique identifier for this layer. | | Option 2 | relationships | object | Holds references to objects related to the Layer entity, such as its members. | | relationships | members | object | Holds an array of references to the members of a Layer, each containing member IDs. | | members | data | [object] | The list of members who belong to this layer. | | data | id [*required*] | string | The unique user ID of the layer member. | | data | type [*required*] | enum | Members resource type. Allowed enum values: `members` | | Option 2 | type [*required*] | enum | Layers resource type. Allowed enum values: `layers` | | included | Option 3 | object | Represents a single member entry in a schedule, referencing a specific user. | | Option 3 | id | string | The unique identifier for this schedule member. | | Option 3 | relationships | object | Defines relationships for a schedule member, primarily referencing a single user. | | relationships | user | object | Wraps the user data reference for a schedule member. | | user | data [*required*] | object | Points to the user data associated with this schedule member, including an ID and type. | | data | id [*required*] | string | The user's unique identifier. | | data | type [*required*] | enum | Users resource type. Allowed enum values: `users` | | Option 3 | type [*required*] | enum | Schedule Members resource type. Allowed enum values: `members` | | included | Option 4 | object | Represents a user object in the context of a schedule, including their `id`, type, and basic attributes. | | Option 4 | attributes | object | Provides basic user information for a schedule, including a name and email address. | | attributes | email | string | The user's email address. | | attributes | name | string | The user's name. | | attributes | status | enum | The user's status. Allowed enum values: `active,deactivated,pending` | | Option 4 | id | string | The unique user identifier. | | Option 4 | type [*required*] | enum | Users resource type. Allowed enum values: `users` | {% /tab %} {% tab title="Example" %} ```json { "data": { "attributes": { "name": "On-Call Schedule", "time_zone": "America/New_York" }, "id": "3653d3c6-0c75-11ea-ad28-fb5701eabc7d", "relationships": { "layers": { "data": [ { "id": "00000000-0000-0000-0000-000000000001", "type": "layers" } ] }, "teams": { "data": [ { "id": "00000000-da3a-0000-0000-000000000000", "type": "teams" } ] } }, "type": "schedules" }, "included": [ { "attributes": { "avatar": "", "description": "Team 1 description", "handle": "team1", "name": "Team 1" }, "id": "00000000-da3a-0000-0000-000000000000", "type": "teams" }, { "attributes": { "effective_date": "2025-02-03T05:00:00Z", "end_date": "2025-12-31T00:00:00Z", "interval": { "days": 1 }, "name": "Layer 1", "restrictions": [ { "end_day": "friday", "end_time": "17:00:00", "start_day": "monday", "start_time": "09:00:00" } ], "rotation_start": "2025-02-01T00:00:00Z" }, "id": "00000000-0000-0000-0000-000000000001", "relationships": { "members": { "data": [ { "id": "00000000-0000-0000-0000-000000000002", "type": "members" } ] } }, "type": "layers" }, { "id": "00000000-0000-0000-0000-000000000002", "relationships": { "user": { "data": { "id": "00000000-aba1-0000-0000-000000000000", "type": "users" } } }, "type": "members" }, { "attributes": { "email": "foo@bar.com", "name": "User 1" }, "id": "00000000-aba1-0000-0000-000000000000", "type": "users" } ] } ``` {% /tab %} {% /tab %} {% tab title="400" %} Bad Request {% tab title="Model" %} API error response. | Field | Type | Description | | ------------------------ | -------- | ----------------- | | errors [*required*] | [string] | A list of errors. | {% /tab %} {% tab title="Example" %} ```json { "errors": [ "Bad Request" ] } ``` {% /tab %} {% /tab %} {% tab title="401" %} Unauthorized {% tab title="Model" %} API error response. | Field | Type | Description | | ------------------------ | -------- | ----------------- | | errors [*required*] | [string] | A list of errors. | {% /tab %} {% tab title="Example" %} ```json { "errors": [ "Bad Request" ] } ``` {% /tab %} {% /tab %} {% tab title="403" %} Forbidden {% tab title="Model" %} API error response. | Field | Type | Description | | ------------------------ | -------- | ----------------- | | errors [*required*] | [string] | A list of errors. | {% /tab %} {% tab title="Example" %} ```json { "errors": [ "Bad Request" ] } ``` {% /tab %} {% /tab %} {% tab title="429" %} Too many requests {% tab title="Model" %} API error response. | Field | Type | Description | | ------------------------ | -------- | ----------------- | | errors [*required*] | [string] | A list of errors. | {% /tab %} {% tab title="Example" %} ```json { "errors": [ "Bad Request" ] } ``` {% /tab %} {% /tab %} ### Code Example ##### \## default # \# Curl command curl -X POST "https://api.datadoghq.com/api/v2/on-call/schedules" \ -H "Accept: application/json" \ -H "Content-Type: application/json" \ -H "DD-API-KEY: ${DD_API_KEY}" \ -H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \ -d @- << EOF { "data": { "attributes": { "layers": [ { "effective_date": "2025-02-03T05:00:00Z", "end_date": "2025-12-31T00:00:00Z", "interval": { "days": 1 }, "members": [ { "user": { "id": "00000000-aba1-0000-0000-000000000000" } } ], "name": "Layer 1", "restrictions": [ { "end_day": "friday", "end_time": "17:00:00", "start_day": "monday", "start_time": "09:00:00" } ], "rotation_start": "2025-02-01T00:00:00Z" } ], "name": "On-Call Schedule", "time_zone": "America/New_York" }, "relationships": { "teams": { "data": [ { "id": "00000000-da3a-0000-0000-000000000000", "type": "teams" } ] } }, "type": "schedules" } } EOF ##### ```go // Create On-Call schedule returns "Created" response package main import ( "context" "encoding/json" "fmt" "os" "time" "github.com/DataDog/datadog-api-client-go/v2/api/datadog" "github.com/DataDog/datadog-api-client-go/v2/api/datadogV2" ) func main() { // there is a valid "user" in the system UserDataID := os.Getenv("USER_DATA_ID") // there is a valid "dd_team" in the system DdTeamDataID := os.Getenv("DD_TEAM_DATA_ID") body := datadogV2.ScheduleCreateRequest{ Data: datadogV2.ScheduleCreateRequestData{ Attributes: datadogV2.ScheduleCreateRequestDataAttributes{ Layers: []datadogV2.ScheduleCreateRequestDataAttributesLayersItems{ { EffectiveDate: time.Now().AddDate(0, 0, -10), EndDate: datadog.PtrTime(time.Now().AddDate(0, 0, 10)), Interval: datadogV2.LayerAttributesInterval{ Days: datadog.PtrInt32(1), }, Members: []datadogV2.ScheduleRequestDataAttributesLayersItemsMembersItems{ { User: &datadogV2.ScheduleRequestDataAttributesLayersItemsMembersItemsUser{ Id: datadog.PtrString(UserDataID), }, }, }, Name: "Layer 1", Restrictions: []datadogV2.TimeRestriction{ { EndDay: datadogV2.WEEKDAY_FRIDAY.Ptr(), EndTime: datadog.PtrString("17:00:00"), StartDay: datadogV2.WEEKDAY_MONDAY.Ptr(), StartTime: datadog.PtrString("09:00:00"), }, }, RotationStart: time.Now().AddDate(0, 0, -5), }, }, Name: "Example-On-Call", TimeZone: "America/New_York", }, Relationships: &datadogV2.ScheduleCreateRequestDataRelationships{ Teams: &datadogV2.DataRelationshipsTeams{ Data: []datadogV2.DataRelationshipsTeamsDataItems{ { Id: DdTeamDataID, Type: datadogV2.DATARELATIONSHIPSTEAMSDATAITEMSTYPE_TEAMS, }, }, }, }, Type: datadogV2.SCHEDULECREATEREQUESTDATATYPE_SCHEDULES, }, } ctx := datadog.NewDefaultContext(context.Background()) configuration := datadog.NewConfiguration() apiClient := datadog.NewAPIClient(configuration) api := datadogV2.NewOnCallApi(apiClient) resp, r, err := api.CreateOnCallSchedule(ctx, body, *datadogV2.NewCreateOnCallScheduleOptionalParameters()) if err != nil { fmt.Fprintf(os.Stderr, "Error when calling `OnCallApi.CreateOnCallSchedule`: %v\n", err) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) } responseContent, _ := json.MarshalIndent(resp, "", " ") fmt.Fprintf(os.Stdout, "Response from `OnCallApi.CreateOnCallSchedule`:\n%s\n", responseContent) } ``` #### Instructions First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=go) and then save the example to `main.go` and run following commands: DD_SITE="datadoghq.com" DD_API_KEY="" DD_APP_KEY="" go run "main.go" ##### ```java // Create On-Call schedule returns "Created" response import com.datadog.api.client.ApiClient; import com.datadog.api.client.ApiException; import com.datadog.api.client.v2.api.OnCallApi; import com.datadog.api.client.v2.model.DataRelationshipsTeams; import com.datadog.api.client.v2.model.DataRelationshipsTeamsDataItems; import com.datadog.api.client.v2.model.DataRelationshipsTeamsDataItemsType; import com.datadog.api.client.v2.model.LayerAttributesInterval; import com.datadog.api.client.v2.model.Schedule; import com.datadog.api.client.v2.model.ScheduleCreateRequest; import com.datadog.api.client.v2.model.ScheduleCreateRequestData; import com.datadog.api.client.v2.model.ScheduleCreateRequestDataAttributes; import com.datadog.api.client.v2.model.ScheduleCreateRequestDataAttributesLayersItems; import com.datadog.api.client.v2.model.ScheduleCreateRequestDataRelationships; import com.datadog.api.client.v2.model.ScheduleCreateRequestDataType; import com.datadog.api.client.v2.model.ScheduleRequestDataAttributesLayersItemsMembersItems; import com.datadog.api.client.v2.model.ScheduleRequestDataAttributesLayersItemsMembersItemsUser; import com.datadog.api.client.v2.model.TimeRestriction; import com.datadog.api.client.v2.model.Weekday; import java.time.OffsetDateTime; import java.util.Collections; public class Example { public static void main(String[] args) { ApiClient defaultClient = ApiClient.getDefaultApiClient(); OnCallApi apiInstance = new OnCallApi(defaultClient); // there is a valid "user" in the system String USER_DATA_ID = System.getenv("USER_DATA_ID"); // there is a valid "dd_team" in the system String DD_TEAM_DATA_ID = System.getenv("DD_TEAM_DATA_ID"); ScheduleCreateRequest body = new ScheduleCreateRequest() .data( new ScheduleCreateRequestData() .attributes( new ScheduleCreateRequestDataAttributes() .layers( Collections.singletonList( new ScheduleCreateRequestDataAttributesLayersItems() .effectiveDate(OffsetDateTime.now().plusDays(-10)) .endDate(OffsetDateTime.now().plusDays(10)) .interval(new LayerAttributesInterval().days(1)) .members( Collections.singletonList( new ScheduleRequestDataAttributesLayersItemsMembersItems() .user( new ScheduleRequestDataAttributesLayersItemsMembersItemsUser() .id(USER_DATA_ID)))) .name("Layer 1") .restrictions( Collections.singletonList( new TimeRestriction() .endDay(Weekday.FRIDAY) .endTime("17:00:00") .startDay(Weekday.MONDAY) .startTime("09:00:00"))) .rotationStart(OffsetDateTime.now().plusDays(-5)))) .name("Example-On-Call") .timeZone("America/New_York")) .relationships( new ScheduleCreateRequestDataRelationships() .teams( new DataRelationshipsTeams() .data( Collections.singletonList( new DataRelationshipsTeamsDataItems() .id(DD_TEAM_DATA_ID) .type(DataRelationshipsTeamsDataItemsType.TEAMS))))) .type(ScheduleCreateRequestDataType.SCHEDULES)); try { Schedule result = apiInstance.createOnCallSchedule(body); System.out.println(result); } catch (ApiException e) { System.err.println("Exception when calling OnCallApi#createOnCallSchedule"); System.err.println("Status code: " + e.getCode()); System.err.println("Reason: " + e.getResponseBody()); System.err.println("Response headers: " + e.getResponseHeaders()); e.printStackTrace(); } } } ``` #### Instructions First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=java) and then save the example to `Example.java` and run following commands: DD_SITE="datadoghq.com" DD_API_KEY="" DD_APP_KEY="" java "Example.java" ##### ```python """ Create On-Call schedule returns "Created" response """ from datetime import datetime from dateutil.relativedelta import relativedelta from os import environ from datadog_api_client import ApiClient, Configuration from datadog_api_client.v2.api.on_call_api import OnCallApi from datadog_api_client.v2.model.data_relationships_teams import DataRelationshipsTeams from datadog_api_client.v2.model.data_relationships_teams_data_items import DataRelationshipsTeamsDataItems from datadog_api_client.v2.model.data_relationships_teams_data_items_type import DataRelationshipsTeamsDataItemsType from datadog_api_client.v2.model.layer_attributes_interval import LayerAttributesInterval from datadog_api_client.v2.model.schedule_create_request import ScheduleCreateRequest from datadog_api_client.v2.model.schedule_create_request_data import ScheduleCreateRequestData from datadog_api_client.v2.model.schedule_create_request_data_attributes import ScheduleCreateRequestDataAttributes from datadog_api_client.v2.model.schedule_create_request_data_attributes_layers_items import ( ScheduleCreateRequestDataAttributesLayersItems, ) from datadog_api_client.v2.model.schedule_create_request_data_relationships import ( ScheduleCreateRequestDataRelationships, ) from datadog_api_client.v2.model.schedule_create_request_data_type import ScheduleCreateRequestDataType from datadog_api_client.v2.model.schedule_request_data_attributes_layers_items_members_items import ( ScheduleRequestDataAttributesLayersItemsMembersItems, ) from datadog_api_client.v2.model.schedule_request_data_attributes_layers_items_members_items_user import ( ScheduleRequestDataAttributesLayersItemsMembersItemsUser, ) from datadog_api_client.v2.model.time_restriction import TimeRestriction from datadog_api_client.v2.model.weekday import Weekday # there is a valid "user" in the system USER_DATA_ID = environ["USER_DATA_ID"] # there is a valid "dd_team" in the system DD_TEAM_DATA_ID = environ["DD_TEAM_DATA_ID"] body = ScheduleCreateRequest( data=ScheduleCreateRequestData( attributes=ScheduleCreateRequestDataAttributes( layers=[ ScheduleCreateRequestDataAttributesLayersItems( effective_date=(datetime.now() + relativedelta(days=-10)), end_date=(datetime.now() + relativedelta(days=10)), interval=LayerAttributesInterval( days=1, ), members=[ ScheduleRequestDataAttributesLayersItemsMembersItems( user=ScheduleRequestDataAttributesLayersItemsMembersItemsUser( id=USER_DATA_ID, ), ), ], name="Layer 1", restrictions=[ TimeRestriction( end_day=Weekday.FRIDAY, end_time="17:00:00", start_day=Weekday.MONDAY, start_time="09:00:00", ), ], rotation_start=(datetime.now() + relativedelta(days=-5)), ), ], name="Example-On-Call", time_zone="America/New_York", ), relationships=ScheduleCreateRequestDataRelationships( teams=DataRelationshipsTeams( data=[ DataRelationshipsTeamsDataItems( id=DD_TEAM_DATA_ID, type=DataRelationshipsTeamsDataItemsType.TEAMS, ), ], ), ), type=ScheduleCreateRequestDataType.SCHEDULES, ), ) configuration = Configuration() with ApiClient(configuration) as api_client: api_instance = OnCallApi(api_client) response = api_instance.create_on_call_schedule(body=body) print(response) ``` #### Instructions First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=python) and then save the example to `example.py` and run following commands: DD_SITE="datadoghq.com" DD_API_KEY="" DD_APP_KEY="" python3 "example.py" ##### ```ruby # Create On-Call schedule returns "Created" response require "datadog_api_client" api_instance = DatadogAPIClient::V2::OnCallAPI.new # there is a valid "user" in the system USER_DATA_ID = ENV["USER_DATA_ID"] # there is a valid "dd_team" in the system DD_TEAM_DATA_ID = ENV["DD_TEAM_DATA_ID"] body = DatadogAPIClient::V2::ScheduleCreateRequest.new({ data: DatadogAPIClient::V2::ScheduleCreateRequestData.new({ attributes: DatadogAPIClient::V2::ScheduleCreateRequestDataAttributes.new({ layers: [ DatadogAPIClient::V2::ScheduleCreateRequestDataAttributesLayersItems.new({ effective_date: (Time.now + -10 * 86400), end_date: (Time.now + 10 * 86400), interval: DatadogAPIClient::V2::LayerAttributesInterval.new({ days: 1, }), members: [ DatadogAPIClient::V2::ScheduleRequestDataAttributesLayersItemsMembersItems.new({ user: DatadogAPIClient::V2::ScheduleRequestDataAttributesLayersItemsMembersItemsUser.new({ id: USER_DATA_ID, }), }), ], name: "Layer 1", restrictions: [ DatadogAPIClient::V2::TimeRestriction.new({ end_day: DatadogAPIClient::V2::Weekday::FRIDAY, end_time: "17:00:00", start_day: DatadogAPIClient::V2::Weekday::MONDAY, start_time: "09:00:00", }), ], rotation_start: (Time.now + -5 * 86400), }), ], name: "Example-On-Call", time_zone: "America/New_York", }), relationships: DatadogAPIClient::V2::ScheduleCreateRequestDataRelationships.new({ teams: DatadogAPIClient::V2::DataRelationshipsTeams.new({ data: [ DatadogAPIClient::V2::DataRelationshipsTeamsDataItems.new({ id: DD_TEAM_DATA_ID, type: DatadogAPIClient::V2::DataRelationshipsTeamsDataItemsType::TEAMS, }), ], }), }), type: DatadogAPIClient::V2::ScheduleCreateRequestDataType::SCHEDULES, }), }) p api_instance.create_on_call_schedule(body) ``` #### Instructions First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=ruby) and then save the example to `example.rb` and run following commands: DD_SITE="datadoghq.com" DD_API_KEY="" DD_APP_KEY="" rb "example.rb" ##### ```rust // Create On-Call schedule returns "Created" response use chrono::{DateTime, Utc}; use datadog_api_client::datadog; use datadog_api_client::datadogV2::api_on_call::CreateOnCallScheduleOptionalParams; use datadog_api_client::datadogV2::api_on_call::OnCallAPI; use datadog_api_client::datadogV2::model::DataRelationshipsTeams; use datadog_api_client::datadogV2::model::DataRelationshipsTeamsDataItems; use datadog_api_client::datadogV2::model::DataRelationshipsTeamsDataItemsType; use datadog_api_client::datadogV2::model::LayerAttributesInterval; use datadog_api_client::datadogV2::model::ScheduleCreateRequest; use datadog_api_client::datadogV2::model::ScheduleCreateRequestData; use datadog_api_client::datadogV2::model::ScheduleCreateRequestDataAttributes; use datadog_api_client::datadogV2::model::ScheduleCreateRequestDataAttributesLayersItems; use datadog_api_client::datadogV2::model::ScheduleCreateRequestDataRelationships; use datadog_api_client::datadogV2::model::ScheduleCreateRequestDataType; use datadog_api_client::datadogV2::model::ScheduleRequestDataAttributesLayersItemsMembersItems; use datadog_api_client::datadogV2::model::ScheduleRequestDataAttributesLayersItemsMembersItemsUser; use datadog_api_client::datadogV2::model::TimeRestriction; use datadog_api_client::datadogV2::model::Weekday; #[tokio::main] async fn main() { // there is a valid "user" in the system let user_data_id = std::env::var("USER_DATA_ID").unwrap(); // there is a valid "dd_team" in the system let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap(); let body = ScheduleCreateRequest::new( ScheduleCreateRequestData::new( ScheduleCreateRequestDataAttributes::new( vec![ScheduleCreateRequestDataAttributesLayersItems::new( DateTime::parse_from_rfc3339("2021-11-01T11:11:11+00:00") .expect("Failed to parse datetime") .with_timezone(&Utc), LayerAttributesInterval::new().days(1), vec![ ScheduleRequestDataAttributesLayersItemsMembersItems::new().user( ScheduleRequestDataAttributesLayersItemsMembersItemsUser::new() .id(user_data_id.clone()), ), ], "Layer 1".to_string(), DateTime::parse_from_rfc3339("2021-11-06T11:11:11+00:00") .expect("Failed to parse datetime") .with_timezone(&Utc), ) .end_date( DateTime::parse_from_rfc3339("2021-11-21T11:11:11+00:00") .expect("Failed to parse datetime") .with_timezone(&Utc), ) .restrictions(vec![TimeRestriction::new() .end_day(Weekday::FRIDAY) .end_time("17:00:00".to_string()) .start_day(Weekday::MONDAY) .start_time("09:00:00".to_string())])], "Example-On-Call".to_string(), "America/New_York".to_string(), ), ScheduleCreateRequestDataType::SCHEDULES, ) .relationships(ScheduleCreateRequestDataRelationships::new().teams( DataRelationshipsTeams::new().data(vec![DataRelationshipsTeamsDataItems::new( dd_team_data_id.clone(), DataRelationshipsTeamsDataItemsType::TEAMS, )]), )), ); let configuration = datadog::Configuration::new(); let api = OnCallAPI::with_config(configuration); let resp = api .create_on_call_schedule(body, CreateOnCallScheduleOptionalParams::default()) .await; if let Ok(value) = resp { println!("{:#?}", value); } else { println!("{:#?}", resp.unwrap_err()); } } ``` #### Instructions First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=rust) and then save the example to `src/main.rs` and run following commands: DD_SITE="datadoghq.com" DD_API_KEY="" DD_APP_KEY="" cargo run ##### ```typescript /** * Create On-Call schedule returns "Created" response */ import { client, v2 } from "@datadog/datadog-api-client"; const configuration = client.createConfiguration(); const apiInstance = new v2.OnCallApi(configuration); // there is a valid "user" in the system const USER_DATA_ID = process.env.USER_DATA_ID as string; // there is a valid "dd_team" in the system const DD_TEAM_DATA_ID = process.env.DD_TEAM_DATA_ID as string; const params: v2.OnCallApiCreateOnCallScheduleRequest = { body: { data: { attributes: { layers: [ { effectiveDate: new Date(new Date().getTime() + -10 * 86400 * 1000), endDate: new Date(new Date().getTime() + 10 * 86400 * 1000), interval: { days: 1, }, members: [ { user: { id: USER_DATA_ID, }, }, ], name: "Layer 1", restrictions: [ { endDay: "friday", endTime: "17:00:00", startDay: "monday", startTime: "09:00:00", }, ], rotationStart: new Date(new Date().getTime() + -5 * 86400 * 1000), }, ], name: "Example-On-Call", timeZone: "America/New_York", }, relationships: { teams: { data: [ { id: DD_TEAM_DATA_ID, type: "teams", }, ], }, }, type: "schedules", }, }, }; apiInstance .createOnCallSchedule(params) .then((data: v2.Schedule) => { console.log( "API called successfully. Returned data: " + JSON.stringify(data) ); }) .catch((error: any) => console.error(error)); ``` #### Instructions First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=typescript) and then save the example to `example.ts` and run following commands: DD_SITE="datadoghq.com" DD_API_KEY="" DD_APP_KEY="" tsc "example.ts" {% /tab %}