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

# Rescuable Check

PATCH https://restapi.ordergroove.com/orders/{order_id}/rescuable_check/
Content-Type: application/json

Use this endpoint to evaluate whether an order meets the conditions for being rescuable. Note that the Rescue API also performs this validation internally, so using this endpoint is not required. This endpoint allows merchants to validate an order's eligibility for rescue without initiating the rescue process. The endpoint performs a validation check without making any changes to the actual order and returns a JSON response of what the expected result will be.

Reference: https://docs.ordergroove.com/reference/rest-rpc-api/orders/rescue-copy

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: ordergroove-restrpc
  version: 1.0.0
paths:
  /orders/{order_id}/rescuable_check/:
    patch:
      operationId: rescue-copy
      summary: Rescuable Check
      description: >-
        Use this endpoint to evaluate whether an order meets the conditions for
        being rescuable. Note that the Rescue API also performs this validation
        internally, so using this endpoint is not required. This endpoint allows
        merchants to validate an order's eligibility for rescue without
        initiating the rescue process. The endpoint performs a validation check
        without making any changes to the actual order and returns a JSON
        response of what the expected result will be.
      tags:
        - orders
      parameters:
        - name: order_id
          in: path
          description: Unique Order ID
          required: true
          schema:
            type: string
        - name: x-api-key
          in: header
          required: true
          schema:
            type: string
      responses:
        '200':
          description: '200'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Orders_rescue-copy_Response_200'
        '400':
          description: '400'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Rescue-copyRequestBadRequestError'
        '403':
          description: '403'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Rescue-copyRequestForbiddenError'
        '404':
          description: '404'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Rescue-copyRequestNotFoundError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                place:
                  type: string
                  format: date
                  description: >-
                    Optional parameter that specifies the new order place date
                    time. By default it will use "now". Use yyyy-mm-ddThh:mm:ss
                    as the format for a date time in CST.
servers:
  - url: https://restapi.ordergroove.com
    description: https://restapi.ordergroove.com
components:
  schemas:
    Orders_rescue-copy_Response_200:
      type: object
      properties: {}
      title: Orders_rescue-copy_Response_200
    RescueCopyRequestBadRequestError0:
      type: object
      properties:
        detail:
          type: string
      title: RescueCopyRequestBadRequestError0
    RescueCopyRequestBadRequestError1:
      type: object
      properties:
        place:
          type: array
          items:
            type: string
      title: RescueCopyRequestBadRequestError1
    RescueCopyRequestBadRequestError2:
      type: object
      properties:
        detail:
          type: string
      title: RescueCopyRequestBadRequestError2
    RescueCopyRequestBadRequestError3:
      type: object
      properties:
        detail:
          type: string
      title: RescueCopyRequestBadRequestError3
    Rescue-copyRequestBadRequestError:
      oneOf:
        - $ref: '#/components/schemas/RescueCopyRequestBadRequestError0'
        - $ref: '#/components/schemas/RescueCopyRequestBadRequestError1'
        - $ref: '#/components/schemas/RescueCopyRequestBadRequestError2'
        - $ref: '#/components/schemas/RescueCopyRequestBadRequestError3'
      title: Rescue-copyRequestBadRequestError
    Rescue-copyRequestForbiddenError:
      type: object
      properties:
        detail:
          type: string
      title: Rescue-copyRequestForbiddenError
    Rescue-copyRequestNotFoundError:
      type: object
      properties:
        detail:
          type: string
      title: Rescue-copyRequestNotFoundError
  securitySchemes:
    x-api-key:
      type: apiKey
      in: header
      name: x-api-key

```

## Examples



**Request**

```json
{}
```

**Response**

```json
{}
```

**SDK Code**

```python Result
import requests

url = "https://restapi.ordergroove.com/orders/order_id/rescuable_check/"

payload = {}
headers = {
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Result
const url = 'https://restapi.ordergroove.com/orders/order_id/rescuable_check/';
const options = {
  method: 'PATCH',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{}'
};

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

```go Result
package main

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

func main() {

	url := "https://restapi.ordergroove.com/orders/order_id/rescuable_check/"

	payload := strings.NewReader("{}")

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

	req.Header.Add("x-api-key", "<apiKey>")
	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 Result
require 'uri'
require 'net/http'

url = URI("https://restapi.ordergroove.com/orders/order_id/rescuable_check/")

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

request = Net::HTTP::Patch.new(url)
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{}"

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

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

HttpResponse<String> response = Unirest.patch("https://restapi.ordergroove.com/orders/order_id/rescuable_check/")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://restapi.ordergroove.com/orders/order_id/rescuable_check/', [
  'body' => '{}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Result
using RestSharp;

var client = new RestClient("https://restapi.ordergroove.com/orders/order_id/rescuable_check/");
var request = new RestRequest(Method.PATCH);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Result
import Foundation

let headers = [
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://restapi.ordergroove.com/orders/order_id/rescuable_check/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()
```