> 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.

# Void subscription entitlements

POST https://restapi.ordergroove.com/subscriptions/{subscription_id}/void_entitlements/
Content-Type: application/json

Voids the live entitlements granted by a cancelled or deactivated digital plan subscription, ending the customer's access to the plan's resources. The subscription itself is not changed.

The subscription must be inactive (`live: false`) and its product must be a digital plan; otherwise the request returns `400`. Entitlements that another of the customer's live subscriptions also grants are skipped unless `void_shared_entitlements` is `true`.

Voiding expires the whole entitlement, including any time granted by other purchases of the same plan.

If some voids fail, the request returns `200` with `status: partial`. Call the endpoint again to retry them.

This endpoint accepts the Application API Scope only. Storefront API Scope signatures are rejected. An API key needs write access.

Reference: https://docs.ordergroove.com/reference/rest-rpc-api/subscriptions/void-entitlements

## Authentication

- `x-api-key` header (required) — Application API Scope — server-to-server, sent in the `x-api-key` header. See [Authentication](/api-reference/authentication).

## Request

### Path parameters

- `subscription_id` (string, required) — Unique Subscription ID

### Body (application/json)

This endpoint expects an object.

- `void_shared_entitlements` (boolean, optional, default: false) — Whether to also void entitlements that another of the customer's live subscriptions grants to the same grantees. When `false`, those entitlements are skipped and listed in `skipped_shared_entitlement_ids`. Must be a JSON boolean; strings such as `"true"` are rejected with `400`.

## Response

### 200

Every matched entitlement was voided, some were voided and some failed, or there was nothing to void. Check `status`.

- `status` (enum, required) — Overall outcome of the request.
  - Allowed values: `success`, `partial`, `failed`, `nothing_to_void`
- `voided_entitlement_ids` (list of string, required) — Public IDs of the entitlements that were voided.
- `failed_entitlement_ids` (list of string, required) — Public IDs of the entitlements that could not be voided. They are still live.
- `skipped_shared_entitlement_ids` (list of string, required) — Public IDs of the entitlements left live because another of the customer's live subscriptions grants them. Always empty when `void_shared_entitlements` is `true`.
- `error` (string, required, nullable) — Why entitlements failed to void, or why the entitlements could not be listed. `null` when nothing failed.
- `message` (string, required, nullable) — Explains any skipped shared entitlements and how to void them. `null` when none were skipped.

## Errors

### 400 Bad Request Error

The subscription is still live, its product is not a digital plan, or `void_shared_entitlements` is not a boolean. Nothing is voided.

- `detail` (string, optional)
- `void_shared_entitlements` (string, optional)

### 403 Forbidden Error

The request was signed with the Storefront API Scope, the API key does not have write access, or the authenticated user cannot be identified to the entitlements service. Nothing is voided.

- `detail` (string, optional)

### 404 Not Found Error

No subscription with this ID exists for the merchant.

- `detail` (string, optional)

### 502 Bad Gateway Error

No entitlement could be voided, or the customer's entitlements could not be listed. `status` is `failed`. When listing fails, nothing is voided and `failed_entitlement_ids` is empty.

- `status` (enum, required) — Overall outcome of the request.
  - Allowed values: `success`, `partial`, `failed`, `nothing_to_void`
- `voided_entitlement_ids` (list of string, required) — Public IDs of the entitlements that were voided.
- `failed_entitlement_ids` (list of string, required) — Public IDs of the entitlements that could not be voided. They are still live.
- `skipped_shared_entitlement_ids` (list of string, required) — Public IDs of the entitlements left live because another of the customer's live subscriptions grants them. Always empty when `void_shared_entitlements` is `true`.
- `error` (string, required, nullable) — Why entitlements failed to void, or why the entitlements could not be listed. `null` when nothing failed.
- `message` (string, required, nullable) — Explains any skipped shared entitlements and how to void them. `null` when none were skipped.

## Examples

### Success

**Response**

```json
{
  "status": "success",
  "voided_entitlement_ids": [
    "4f9c2b7e8a1d4c3b9e6f0a2d5c7b8e1f"
  ],
  "failed_entitlement_ids": [],
  "skipped_shared_entitlement_ids": [],
  "error": null,
  "message": null
}
```

**SDK Code**

```python Success
import requests

url = "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/"

headers = {"x-api-key": "<apiKey>"}

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

print(response.json())
```

```javascript Success
const url = 'https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/';
const options = {method: 'POST', headers: {'x-api-key': '<apiKey>'}};

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

```go Success
package main

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

func main() {

	url := "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/"

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

	req.Header.Add("x-api-key", "<apiKey>")

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

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

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

}
```

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

url = URI("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'

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

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

HttpResponse<String> response = Unirest.post("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")
  .header("x-api-key", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Success
using RestSharp;

var client = new RestClient("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Success
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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()
```

### Partial, with a shared entitlement skipped

**Response**

```json
{
  "status": "partial",
  "voided_entitlement_ids": [
    "4f9c2b7e8a1d4c3b9e6f0a2d5c7b8e1f"
  ],
  "failed_entitlement_ids": [
    "b81e3d6a0c2f4e7a9d5b1c8f3a6e2d40"
  ],
  "skipped_shared_entitlement_ids": [
    "e2a7c95f1b3d4a8e8c6f2d0b7a9e1c53"
  ],
  "error": "1 entitlement(s) failed to void. b81e3d6a0c2f4e7a9d5b1c8f3a6e2d40: Request to entitlements service timed out",
  "message": "1 entitlement was not voided because it is also granted by another active subscription. Pass void_shared_entitlements: true to void it anyway."
}
```

**SDK Code**

```python Partial, with a shared entitlement skipped
import requests

url = "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/"

headers = {"x-api-key": "<apiKey>"}

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

print(response.json())
```

```javascript Partial, with a shared entitlement skipped
const url = 'https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/';
const options = {method: 'POST', headers: {'x-api-key': '<apiKey>'}};

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

```go Partial, with a shared entitlement skipped
package main

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

func main() {

	url := "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/"

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

	req.Header.Add("x-api-key", "<apiKey>")

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

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

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

}
```

```ruby Partial, with a shared entitlement skipped
require 'uri'
require 'net/http'

url = URI("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'

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

```java Partial, with a shared entitlement skipped
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Partial, with a shared entitlement skipped
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Partial, with a shared entitlement skipped
using RestSharp;

var client = new RestClient("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Partial, with a shared entitlement skipped
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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()
```

### Nothing to void

**Response**

```json
{
  "status": "nothing_to_void",
  "voided_entitlement_ids": [],
  "failed_entitlement_ids": [],
  "skipped_shared_entitlement_ids": [],
  "error": null,
  "message": null
}
```

**SDK Code**

```python Nothing to void
import requests

url = "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/"

headers = {"x-api-key": "<apiKey>"}

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

print(response.json())
```

```javascript Nothing to void
const url = 'https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/';
const options = {method: 'POST', headers: {'x-api-key': '<apiKey>'}};

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

```go Nothing to void
package main

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

func main() {

	url := "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/"

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

	req.Header.Add("x-api-key", "<apiKey>")

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

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

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

}
```

```ruby Nothing to void
require 'uri'
require 'net/http'

url = URI("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'

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

```java Nothing to void
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")
  .header("x-api-key", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Nothing to void
using RestSharp;

var client = new RestClient("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Nothing to void
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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()
```

### Nothing voided, all shared

**Response**

```json
{
  "status": "nothing_to_void",
  "voided_entitlement_ids": [],
  "failed_entitlement_ids": [],
  "skipped_shared_entitlement_ids": [
    "e2a7c95f1b3d4a8e8c6f2d0b7a9e1c53"
  ],
  "error": null,
  "message": "All matched entitlements are also granted by another active subscription, so none were voided. Pass void_shared_entitlements: true to void them anyway."
}
```

**SDK Code**

```python Nothing voided, all shared
import requests

url = "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/"

headers = {"x-api-key": "<apiKey>"}

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

print(response.json())
```

```javascript Nothing voided, all shared
const url = 'https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/';
const options = {method: 'POST', headers: {'x-api-key': '<apiKey>'}};

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

```go Nothing voided, all shared
package main

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

func main() {

	url := "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/"

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

	req.Header.Add("x-api-key", "<apiKey>")

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

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

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

}
```

```ruby Nothing voided, all shared
require 'uri'
require 'net/http'

url = URI("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'

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

```java Nothing voided, all shared
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Nothing voided, all shared
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Nothing voided, all shared
using RestSharp;

var client = new RestClient("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Nothing voided, all shared
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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()
```

### Default

**Request**

```json
{}
```

**Response**

```json
{
  "status": "success",
  "voided_entitlement_ids": [
    "4f9c2b7e8a1d4c3b9e6f0a2d5c7b8e1f"
  ],
  "failed_entitlement_ids": [],
  "skipped_shared_entitlement_ids": [],
  "error": null,
  "message": null
}
```

**SDK Code**

```python Default
import requests

url = "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/"

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

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

print(response.json())
```

```javascript Default
const url = 'https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/';
const options = {
  method: 'POST',
  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 Default
package main

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

func main() {

	url := "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/"

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

	req, _ := http.NewRequest("POST", 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 Default
require 'uri'
require 'net/http'

url = URI("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")

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

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

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

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

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

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

$client = new \GuzzleHttp\Client();

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

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

```csharp Default
using RestSharp;

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

```swift Default
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/subscriptions/subscription_id/void_entitlements/")! 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()
```

### Void shared entitlements

**Request**

```json
{
  "void_shared_entitlements": true
}
```

**Response**

```json
{
  "status": "success",
  "voided_entitlement_ids": [
    "4f9c2b7e8a1d4c3b9e6f0a2d5c7b8e1f"
  ],
  "failed_entitlement_ids": [],
  "skipped_shared_entitlement_ids": [],
  "error": null,
  "message": null
}
```

**SDK Code**

```python Void shared entitlements
import requests

url = "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/"

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

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

print(response.json())
```

```javascript Void shared entitlements
const url = 'https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"void_shared_entitlements":true}'
};

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

```go Void shared entitlements
package main

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

func main() {

	url := "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/"

	payload := strings.NewReader("{\n  \"void_shared_entitlements\": true\n}")

	req, _ := http.NewRequest("POST", 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 Void shared entitlements
require 'uri'
require 'net/http'

url = URI("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")

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

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

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

```java Void shared entitlements
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"void_shared_entitlements\": true\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/', [
  'body' => '{
  "void_shared_entitlements": true
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Void shared entitlements
using RestSharp;

var client = new RestClient("https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"void_shared_entitlements\": true\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Void shared entitlements
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://restapi.ordergroove.com/subscriptions/subscription_id/void_entitlements/")! 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()
```