> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.ninjatrader.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.ninjatrader.com/_mcp/server.

# Take Alert Signal Ownership

POST https://demo.tradovateapi.com/v1/adminAlertSignal/takealertsignalownership
Content-Type: application/json

### Claim ownership of an admin alert signal for handling.

**Available to:** All authenticated users

**Environments:** Demo, Live

**[Rate Limit](/api/authentication#request-rate-limits-and-time-penalties):** No endpoint-specific limit

Claims an admin alert signal so the calling user becomes responsible for working it. An admin alert signal is an internal alerting record that flags a situation for staff or B2B partner follow-up (for example, a signal related to a specific account or user). Taking ownership records the caller as the owner and stamps the time the signal was claimed, so the same signal isn't worked twice. Identify the signal with `adminAlertSignalId` (the integer entity ID).

A signal tied to a public admin alert cannot be owned — ownership applies only to signals that require individual handling.

On success, the response returns the updated `adminAlertSignal` reflecting the new owner and an empty `errorText`. On a handled failure, the response carries a non-empty `errorText` describing the problem.

**Common Failure Scenarios**

- The signal belongs to a public admin alert, which cannot be owned.
- The `adminAlertSignalId` doesn't exist or isn't accessible to the caller.
- The access token is missing or invalid (returns `HTTP 401`).

**Error Messages**

| `errorText` | Trigger |
|-------------|---------|
| `"Public alert cannot be owned"` | The signal is tied to a public admin alert. |
| Non-empty `errorText` | The request failed; the field describes the reason. |

Reference: https://docs.ninjatrader.com/api/rest-api-endpoints/alerts/take-alert-signal-ownership

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: public
  version: 1.0.0
paths:
  /adminAlertSignal/takealertsignalownership:
    post:
      operationId: takeAlertSignalOwnership
      summary: Take Alert Signal Ownership
      description: >-
        ### Claim ownership of an admin alert signal for handling.


        **Available to:** All authenticated users


        **Environments:** Demo, Live


        **[Rate
        Limit](/api/authentication#request-rate-limits-and-time-penalties):** No
        endpoint-specific limit


        Claims an admin alert signal so the calling user becomes responsible for
        working it. An admin alert signal is an internal alerting record that
        flags a situation for staff or B2B partner follow-up (for example, a
        signal related to a specific account or user). Taking ownership records
        the caller as the owner and stamps the time the signal was claimed, so
        the same signal isn't worked twice. Identify the signal with
        `adminAlertSignalId` (the integer entity ID).


        A signal tied to a public admin alert cannot be owned — ownership
        applies only to signals that require individual handling.


        On success, the response returns the updated `adminAlertSignal`
        reflecting the new owner and an empty `errorText`. On a handled failure,
        the response carries a non-empty `errorText` describing the problem.


        **Common Failure Scenarios**


        - The signal belongs to a public admin alert, which cannot be owned.

        - The `adminAlertSignalId` doesn't exist or isn't accessible to the
        caller.

        - The access token is missing or invalid (returns `HTTP 401`).


        **Error Messages**


        | `errorText` | Trigger |

        |-------------|---------|

        | `"Public alert cannot be owned"` | The signal is tied to a public
        admin alert. |

        | Non-empty `errorText` | The request failed; the field describes the
        reason. |
      tags:
        - Alerts
      parameters:
        - name: Authorization
          in: header
          description: Bearer authentication
          required: true
          schema:
            type: string
      responses:
        '200':
          description: AdminAlertSignalResponse
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AdminAlertSignalResponse'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/TakeAlertSignalOwnership'
servers:
  - url: https://demo.tradovateapi.com/v1
    description: Demo
  - url: https://live.tradovateapi.com/v1
    description: Live
components:
  schemas:
    TakeAlertSignalOwnership:
      type: object
      properties:
        adminAlertSignalId:
          type: integer
          format: int64
      required:
        - adminAlertSignalId
      title: TakeAlertSignalOwnership
    AdminAlertSignal:
      type: object
      properties:
        id:
          type: integer
          format: int64
        timestamp:
          type: string
          format: date-time
        adminAlertId:
          type: integer
          format: int64
        relatedToAccountId:
          type: integer
          format: int64
        relatedToUserId:
          type: integer
          format: int64
        ownedByAdminId:
          type: integer
          format: int64
          description: Owned By...
        completed:
          type: string
          format: date-time
        text:
          type: string
        emailSent:
          type: boolean
        subjectId:
          type: integer
          format: int64
        claimedAt:
          type: string
          format: date-time
      required:
        - timestamp
        - adminAlertId
        - text
        - emailSent
        - subjectId
      title: AdminAlertSignal
    AdminAlertSignalResponse:
      type: object
      properties:
        errorText:
          type: string
          description: Non-empty if the request failed
        adminAlertSignal:
          $ref: '#/components/schemas/AdminAlertSignal'
      title: AdminAlertSignalResponse
  securitySchemes:
    bearer_access_token:
      type: http
      scheme: bearer

```

## Examples



**Request**

```json
{
  "adminAlertSignalId": 1
}
```

**Response**

```json
{
  "errorText": "string",
  "adminAlertSignal": {
    "timestamp": "2024-01-15T09:30:00Z",
    "adminAlertId": 1,
    "text": "string",
    "emailSent": true,
    "subjectId": 1,
    "id": 1,
    "relatedToAccountId": 1,
    "relatedToUserId": 1,
    "ownedByAdminId": 1,
    "completed": "2024-01-15T09:30:00Z",
    "claimedAt": "2024-01-15T09:30:00Z"
  }
}
```

**SDK Code**

```python
import requests

url = "https://demo.tradovateapi.com/v1/adminAlertSignal/takealertsignalownership"

payload = { "adminAlertSignalId": 1 }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://demo.tradovateapi.com/v1/adminAlertSignal/takealertsignalownership';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"adminAlertSignalId":1}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://demo.tradovateapi.com/v1/adminAlertSignal/takealertsignalownership"

	payload := strings.NewReader("{\n  \"adminAlertSignalId\": 1\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://demo.tradovateapi.com/v1/adminAlertSignal/takealertsignalownership")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"adminAlertSignalId\": 1\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://demo.tradovateapi.com/v1/adminAlertSignal/takealertsignalownership")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"adminAlertSignalId\": 1\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://demo.tradovateapi.com/v1/adminAlertSignal/takealertsignalownership', [
  'body' => '{
  "adminAlertSignalId": 1
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://demo.tradovateapi.com/v1/adminAlertSignal/takealertsignalownership");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"adminAlertSignalId\": 1\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["adminAlertSignalId": 1] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://demo.tradovateapi.com/v1/adminAlertSignal/takealertsignalownership")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```