Operations and Recovery APIs Archives - SearchStax Docs Documentation Fri, 10 Jul 2026 15:40:13 +0000 en-US hourly 1 https://wordpress.org/?v=7.1.4 https://www.searchstax.com/docs/wp-content/uploads/2023/10/cropped-favicon-32x32.png Operations and Recovery APIs Archives - SearchStax Docs 32 32 Solr Backup/Restore API https://www.searchstax.com/docs/searchstax-cloud-backup-restore-api/ https://www.searchstax.com/docs/searchstax-cloud-backup-restore-api/#respond Thu, 04 Mar 2021 07:56:22 +0000 https://www.searchstax.com/docs/?p=7603 Provisioning API – Backup/Restore Overview The SearchStax Managed Search service provides an API supporting the creation, deletion and management of Solr Cloud deployments. Core and Enterprise Clients Only! The… Continue reading Solr Backup/Restore API

The post Solr Backup/Restore API appeared first on SearchStax Docs.

]]> Provisioning API – Backup/Restore

Overview

The SearchStax Managed Search service provides an API supporting the creation, deletion and management of Solr Cloud deployments.

Core and Enterprise Clients Only!

The SearchStax API suite is available to our Core and Enterprise clients only, as noted on our Pricing page.

This page describes how to perform backup and restore operations through API methods.

The API can be accessed through any tool that assembles HTTP requests and dispatch them to a server. Among these would be the Python coreapi package, the Postman tool, and cURL. For Windows, use PowerShell 7+.

Account Owner, Admin, or Technical Contact

To run the SearchStax Provisioning API, you must be the account Owner, an account Admin, or a Technical Contact. See SearchStax User Roles.

Symbols enclosed in carets (< and >) such as <username> are metavariables. Substitute your local values when you encounter them in the examples.

Contents:

Related Pages:

Account-Level Methods

Backup files do not disappear when you delete the associated deployment. However, the deployment’s ssID (ss123456) becomes invalid, making it impossible to use the deployment-level methods to restore or delete the orphaned backup files.

The following three methods let us list, restore, and delete orphaned backup files from the API.

account > backup > list

This method lists all backups of an account, including deleted backup files.

GET /api/rest/v2/account/<account_name>/backup/

where <account_name> is the name of the tenant account.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account/<account_name>/backup/" 
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"

$BACKUPS = Invoke-RestMethod -Method Get -ContentType 'application/json' -Headers $headers `
              -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/backup/"
$BACKUPS = $BACKUPS | ConvertTo-Json

A successful response contains a JSON object containing a list of backups:

[
    {
      "id": 57198,
      "backup_type": "One time",
      "created": "2020-06-19 04:49:42 PM (2020-06-19 16:49:42 UTC)",
      "status": "Done",
      "size": 223608,
      "region": "US West (N. California)",
      "collections": null,
      "deployment_uid": "ss305854",
      "deployment_name": "QuickStart",
      "version": "8.3.1",
      "cloud": "aws",
      "size_display": "223.61 KB",
      "replication_region": "-",
      "error_message": []
    }
]

account > backup > delete

This method deletes a backup from a deployment.

DELETE /api/rest/v2/account/<account_name>/backup/<buid>/

where <account_name> is the name of the tenant account, and <buid> is the ID of the backup.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request DELETE "https://app.searchstax.com/api/rest/v2/account/<account_name>/backup/<buid>/" 
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$BUID = "27004"

$BACKUPS = Invoke-RestMethod -Method Delete -ContentType 'application/json' -Headers $headers `
              -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/backup/$BUID/"
$BACKUPS = $BACKUPS | ConvertTo-Json

A successful response returns a 204 code and an empty string.

account > restore > create

This method restores an orphaned backup file to a deployment. For more versatile restore options, see account > deployment > restore > create.

Parallel Restoration

Note that restoring a backup takes all collections offline until the restore is complete.

The parallel_restore parameter reduces restore time by rebuilding each collection in a separate thread.

Downtime due to a restore is difficult to estimate, ranging from minutes to hours for very large backup files. Experience must be your guide.

POST https://app.searchstax.com/api/rest/v2/account/<account_name>/restore/

where <account_name> is the name of the tenant account.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    id="27004"
    target_deployment_id="ss123456"
    parallel_restore="true"
}
Parameter Description Example
id
required
string		 The backup id number, from the List Backups method. “27004”
target_deployment_uid
optional
string		 The target deployment ID number. “ss123456”
parallel_restore
optional
string		 Optional ability to restore collections in parallel (multiple threads). Default is “false.” “true”

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account/<account_name>/restore/" 
  --header "Content-Type: application/json" 
  --header "Authorization: Token <token>" 
  --data '{"id":"27004","target_deployment_uid":"ss123456"}'

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"

$body = @{
    id='27004'
    target_deployment_uid='ss123456'
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/restore/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document confirming that the restore has been scheduled.

{
  "message": "restore begun"
}

Deployment-Level Methods

The SearchStax Provisioning API includes methods for performing backup and restore operations. If the backup file has been “orphaned” by deleting the source deployment, use the account-level methods instead.

account > deployment > backup > list

This method lists the existing backups of a deployment.

GET /api/rest/v2/account/<account_name>/deployment/<uid>/backup/

where <account_name> is the name of the tenant account, and <uid> is the ID of the deployment.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/backup/" 
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$BACKUPS = Invoke-RestMethod -Method Get -ContentType 'application/json' -Headers $headers `
              -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/backup/"
$BACKUPS = $BACKUPS | ConvertTo-Json

A successful response contains a JSON object containing a list of backups:

[
    {
        "id":  2318045,
        "backup_type":  "scheduled",
        "created":  "2026-04-21T06:00:06Z",
        "status":  "done",
        "size":  2141854,
        "region":  "Amazon Web Services - us-west-2",
        "collections":  [
                            "filmcollection"
                        ]
    },
        {
        "id":  2317534,
        "backup_type":  "onetime",
        "created":  "2026-04-20T17:05:01Z",
        "status":  "done",
        "size":  2141854,
        "region":  "Amazon Web Services - us-west-2",
        "collections":  [

                        ]
    },
]

Note that the collections list is empty when all collections were backed up, but contains collection names when for a partial backup.

account > deployment > backup > create

This method makes a one-time backup of a deployment. 

POST https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/backup/

where <account_name> is the name of the tenant account, and <uid> is the ID of the deployment.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    region: "us-west-1",
    collections: "[filmcollection]"
}
ParameterDescriptionExample
region
optional
string		The region ID of the region where the backup should be created. Defaults to the deployment’s region. Region codes can be obtained using the List Plans method or from the deployment’s description in the SearchStax dashboard. “us-west-2”
collections
optional
list		List of collections to back up – [] to back up all collectionsBash: [“collection1”, “collection2”]

PowerShell: @(‘collection1’, ‘collection2’)

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/backup/" 
  --header "Content-Type: application/json" 
  --header "Authorization: Token <token>" 
  --data '{"region":"us-west-1","collection":"[filmcollection]"}'

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    region='us-west-1'
    collections=@('filmcollection')
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/backup/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document containing the description of the new backup.

{
  "id": 123456,
  "created": "2019-11-14T19:20:45.903037Z",
  "status": "pending",
  "size": 0,
  "region": "Amazon Web Services - us-west-1"
  "collections": [
     "filmcollection"
     ]
}

account > deployment > backup > delete

This method deletes a backup from a deployment.

DELETE /api/rest/v2/account/<account_name>/deployment/<uid>/backup/<buid>/

where <account_name> is the name of the tenant account, <uid> is the ID of the deployment, and <buid> is the ID of the backup.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request DELETE "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/backup/<buid>/" 
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"
$BUID = "27004"

$BACKUPS = Invoke-RestMethod -Method Delete -ContentType 'application/json' -Headers $headers `
              -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/backup/$BUID/"
$BACKUPS = $BACKUPS | ConvertTo-Json

A successful response is a JSON document containing a confirmation message:

{
  "message": "Successfully deleted backup 27004",
  "success": "true"
}

account > deployment > backup > schedule > list

This method lists the existing backup schedules of a deployment.

GET /api/rest/v2/account/<account_name>/deployment/<uid>/backup/schedule/

where <account_name> is the name of the tenant account, and <uid> is the ID of the deployment.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/backup/schedule/" 
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$BACKUPS = Invoke-RestMethod -Method Get -ContentType 'application/json' -Headers $headers `
              -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/backup/schedule/"

$BACKUPS = $BACKUPS | ConvertTo-Json

A successful response contains a JSON object containing a list of backups:

[
  {
    "id": 1234,
    "days": [
      "mon",
      "tue",
      "wed",
      "thu",
      "fri",
      "sat",
      "sun"
    ],
    "time": "00:00:00",
    "retention": 1,
    "collections": []
  }
]

account > deployment > backup > schedule > create

This method creates a backup schedule for a deployment. 

POST https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/backup/schedule/

where <account_name> is the name of the tenant account, and <uid> is the ID of the deployment.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "retention":  7,
    "days":  [
                 "mon",
                 "wed",
                 "fri"
             ],
    "region_id":  "us-west-1",
    "frequency":  6,
    "collections":  [
                        "filmcollection"
                    ],
    "time":  "07:00"
}
ParameterDescriptionExample
time
optional
string		Time (UTC) the backup should run. (Format: HH:MM)
Either time or frequency must be provided. 		“07:00”
days
required list
List of days on which backup should run relative to UTC time. [“mon”, “tue”, “wed”, “thu”, “fri”, “sat”, “sun”]

[“everyday”]
retention
required number		Number of days to retain the backup.7
frequency
optional
number
At what interval (hours) the backups should run in the day.
Either time or frequency must be provided. 		3
region_id
required
string		The region ID of the region where the backup should be created. Defaults to the deployment’s region.
Region codes can be obtained using the List Plans method or from the deployment’s description in the SearchStax dashboard. 		“us-west-1”
collections
optional
list		List of collections to back up. Defaults to [] to back up all collectionsBash: [“collection1”, “collection2”]

PowerShell: @(‘collection1’, ‘collection2’)

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/backup/schedule/" 
  --header "Content-Type: application/json" 
  --header "Authorization: Token <token>" 
  --data '{"time":"08:30","collections":["filmcollection"],"days":["everyday"],"retention":"7","region_id":"us-west-1"}'

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    days=@('mon', 'wed', 'fri')
    time='07:00'
    frequency=6
    retention=7
    region_id='us-west-1'
    collections=@('filmcollection')
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/backup/schedule/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document confirming success.

{
  "message": "Backup Scheduled Successfully"
}

account > deployment > backup > schedule > delete

This method deletes a backup schedule from a deployment.

DELETE /api/rest/v2/account/<account_name>/deployment/<uid>/backup/schedule/<buid>/

where <account_name> is the name of the tenant account, <uid> is the ID of the deployment, and <buid> is the ID of the backup.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request DELETE "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/backup/schedule/<buid>/" 
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"
$BUID = "27004"

$BACKUPS = Invoke-RestMethod -Method Delete -ContentType 'application/json' -Headers $headers `
              -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/backup/schedule/$BUID/"
$BACKUPS = $BACKUPS | ConvertTo-Json

A successful response is a JSON document containing a confirmation message:

{
  "success": "The backup schedule has been deleted!"
}

account > deployment > restore > create

This method restores a backup to a deployment. Optionally, it can restore one or more individual collections from a multi-collection backup.

Restoring Individual Collections

This method can be used to restore one or more individual collections from a multi-collection backup to a multi-collection deployment. Note that restoring individual collections takes all collections offline until the restore is complete.

The parallel_restore parameter reduces restore time by rebuilding each collection in a separate thread.

Downtime due to a restore is difficult to estimate, ranging from minutes to hours for very large backup files. Experience must be your guide.

POST https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/restore/

where <account_name> is the name of the tenant account, and <uid> is the ID of the deployment.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    backup_id="27004"
    replication_factor="3"
    collection_name="quickstart"
    collections=["Col1", "Col2", "Col3"]
    parallel_restore="true"
}
Parameter Description Example
backup_id
required
string		 The backup id number, from the List Backups method. “27004”
replication_factor
optional
string		 Defaults to the number of nodes in the target cluster. You may ask for fewer replicas, but not for more. “2”
collection_name
optional
string		 [Deprecated.] Optional name of a single collection to restore. “quickstart”
collections
optional
list		 [Preferred.] Optional list of collection names to restore. [“Col1”, “Col2”, “Col3”]
parallel_restore
optional
string		 Optional ability to restore collections in parallel (multiple threads). Default is “false.” “true”

If collection_name and collections are both present, the method will restore all of the listed collections.

If collection_name and collections are both absent, the method will restore all the collections in the backup file, overwriting all previous data on the deployment.

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/restore/" 
  --header "Content-Type: application/json" 
  --header "Authorization: Token <Token>" 
  --data '{"backup_id":"12345678","collections":["collection1","collection3"]}'

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$list = @("collection1","collection3")

$body = @{
    backup_id='12345678'
    collections=$list
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/restore/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document confirming that the restore has been scheduled.

{
  "message": "The restore request has been successfully placed in the Task queue and will be initiated soon. You can check the status with the restore-status API"
}

When performing a partial restore, SearchStax will overwrite the restored collections while preserving any others that are present.

account > deployment > restore > status

This method reports on the status of a restore.

POST /api/rest/v2/account/<account_name>/deployment/<uid>/restore/status/

where <account_name> is the name of the tenant account, <uid> is the ID of the deployment.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/restore/status/" 
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$RESULTS = Invoke-RestMethod -Method Post -ContentType 'application/json' -Headers $headers `
              -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/restore/status/"
$RESULTS = $RESULTS | ConvertTo-Json

The response is a JSON object containing an appropriate message string:

{
  "message": "Backup Restore in Progress"
}

{
  "message": "No restore Running on this deployment"
}

Questions?

Do not hesitate to contact the SearchStax Support Desk.

The post Solr Backup/Restore API appeared first on SearchStax Docs.

]]> https://www.searchstax.com/docs/searchstax-cloud-backup-restore-api/feed/ 0 Solr Tags API https://www.searchstax.com/docs/searchstax-cloud-tags-api/ https://www.searchstax.com/docs/searchstax-cloud-tags-api/#respond Thu, 04 Mar 2021 07:41:46 +0000 https://www.searchstax.com/docs/?p=7590 Provisioning API – Tags Overview The SearchStax Managed Search service provides an API supporting the creation, deletion and management of Solr Cloud deployments. Core and Enterprise Clients Only! The… Continue reading Solr Tags API

The post Solr Tags API appeared first on SearchStax Docs.

]]> Provisioning API – Tags

Overview

The SearchStax Managed Search service provides an API supporting the creation, deletion and management of Solr Cloud deployments.

Core and Enterprise Clients Only!

The SearchStax API suite is available to our Core and Enterprise clients only, as noted on our Pricing page.

This page describes how to add and manage tags using API methods.

The API can be accessed through any tool that assembles HTTP requests and dispatch them to a server. Among these would be the Python coreapi package, the Postman tool, and cURL. For Windows, use PowerShell 7+.

Account Owner, Admin, or Technical Contact

To run the SearchStax Provisioning API, you must be the account Owner, an account Admin, or a Technical Contact. See SearchStax User Roles.

Symbols enclosed in carets (< and >) such as <username> are metavariables. Substitute your local values when you encounter them in the examples.

Contents:

Related Pages:

Tags

account > deployment > tags > create

This method adds one or more tags to a deployment.

POST https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/tags/

where <account_name> is the name of the tenant account, and <uid> is the ID of the deployment.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "tags": ["demo","test"]
}
ParameterDescriptionExample
tags
required
list of strings		A list of tags to add to the deployment.[“demo”, “test”]

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/tags/" \
  --header "Content-Type: application/json" \
  --header "Authorization: Token <token>" \
  --data "{
    \"tags\": [\"demo\",\"test\"]
}"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    tags='demo','test'
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/tags/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a list of JSON documents containing the deployment UID and the deployment’s current set of tags.

{
  "deployment": "ss123456",
  "tags": [
    "test",
    "demo"
  ]
}

An invalid UID will throw a 404 – Not Found error.

account > deployment > tags > delete

This method deletes one or more tags from a deployment.

POST https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/tags/delete/

where <account_name> is the name of the tenant account, and <uid> is the ID of the deployment.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "tags":["test"]
}
ParameterDescriptionExample
tags
required
list of strings		A list of tags to delete.[“test”]

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/tags/delete/" \
  --header "Authorization: Token <token>" \
  --header "Content-Type: application/json" \
  --data "{
    \"tags\":[\"test\"]
}"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    tags='test'
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/tags/delete/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a list of JSON documents identifying the deployment and its current set of tags:

{
  "deployment": "ss123456",
  "tags": []
}

An invalid UID will throw a 404 – Not Found error.

account > deployment > tags > list

This method list a deployment’s current set of tags.

GET https://app.searchstax.com/api/rest/v2/account/&lt;account_name>/deployment/&lt;uid>/tags/

where <account_name> is the name of the tenant account, and <uid> is the ID of the deployment.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/tags/" \
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$RESULT = Invoke-RestMethod -Method Get -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/tags/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a list of JSON documents identifying the deployment and its current set of tags:

{
  "deployment": "ss123456",
  "tags": [
    "test",
    "demo"
  ]
}

account > deployment > tags > get_deployments

This method retrieves all of the deployments that have a specific tag.

POST https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/tags/get-deployments/

where <account_name> is the name of the tenant account.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "tags":["test","demo"],
    "operator":"OR"
}
ParameterDescriptionExample
tags
required
list of strings		A list of tags to match.[“demo”, “test”]
operator
required
string		Operator to apply to the matches.“AND”/”OR”

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/tags/get-deployments/" \
  --header "Authorization: Token <token>" \
  --header "Content-Type: application/json" \
  --data "{
    \"tags\":[\"test\",\"demo\"],
    \"operator\":\"OR\"
}"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"

$body = @{
    tags='demo','test'
    operator='OR'
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/tags/get-deployments/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a list of JSON objects pairing tag matches with specific deployment UIDs.

[
  {
    "tags": [
      "demo"
    ],
    "deployment": "ss123456"
  },
  {
    "tags": [
      "test",
      "demo"
    ],
    "deployment": "ss123456"
  }
]

Questions?

Do not hesitate to contact the SearchStax Support Desk.

The post Solr Tags API appeared first on SearchStax Docs.

]]> https://www.searchstax.com/docs/searchstax-cloud-tags-api/feed/ 0 Solr Alerts API https://www.searchstax.com/docs/searchstax-cloud-alerts-api/ https://www.searchstax.com/docs/searchstax-cloud-alerts-api/#respond Thu, 04 Mar 2021 07:25:39 +0000 https://www.searchstax.com/docs/?p=7575 Provisioning API – Alerts Overview The SearchStax Managed Search service provides an API supporting the creation, deletion and management of Solr Cloud deployments. Core and Enterprise Clients Only! The… Continue reading Solr Alerts API

The post Solr Alerts API appeared first on SearchStax Docs.

]]> Provisioning API – Alerts

Overview

The SearchStax Managed Search service provides an API supporting the creation, deletion and management of Solr Cloud deployments.

Core and Enterprise Clients Only!

The SearchStax API suite is available to our Core and Enterprise clients only, as noted on our Pricing page.

This page describes how to set up and manage alerts through API methods.

The API can be accessed through any tool that assembles HTTP requests and dispatch them to a server. Among these would be the Python coreapi package, the Postman tool, and cURL. For Windows, use PowerShell 7+.

Account Owner, Admin, or Technical Contact

To run the SearchStax Provisioning API, you must be the account Owner, an account Admin, or a Technical Contact. See SearchStax User Roles.

Symbols enclosed in carets (< and >) such as <username> are metavariables. Substitute your local values when you encounter them in the examples.

Contents:

Related Pages:

Alerts

The Provisioning API provides methods for remotely managing alerts and incidents.

account > alerts > metrics

This method generates a list of the metrics that are available for setting alerts.

GET https://app.searchstax.com/api/rest/v2/account/<account_name>/alerts/metrics/

where <account_name> is the name of the tenant account.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account/<account_name>/alerts/metrics/" \
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"

$RESULTS = Invoke-RestMethod -Method Get -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/alerts/metrics/" 
$RESULTS = $RESULTS | ConvertTo-Json | Out-File C:\metrics.txt

The response is a list of JSON objects describing individual metrics.

[
    {
        "name":  "system_cpu_usage",
        "unit":  [
                     "percentage"
                 ],
        "description":  "Metrics for CPU usage in percentage."
    },
    {
        "name":  "system_disk_space_used",
        "unit":  [
                     "KB",
                     "MB",
                     "GB"
                 ],
        "description":  "Used disk space on this device."
    },
    {
        "name":  "system_disk_space_free",
        "unit":  [
                     "KB",
                     "MB",
                     "GB"
                 ],
        "description":  "Free Disk space left on the device."
    },
    {
        "name":  "search_timeouts",
        "unit":  [
                     "number"
                 ],
        "description":  "Timeouts reported while performing a search in Solr."
    }
]

account > deployment > incidents

This method lists the incidents for a deployment. (Incidents are created by alerts.)

GET https://app.searchstax.com/api/rest/v2/account/{account_name}/deployment/{uid}/incidents/

where <account_name> is the name of the tenant account, and <uid> is the ID of the deployment.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/incidents/" \
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$RESULTS = Invoke-RestMethod -Method Get -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/incidents/" 
$RESULTS = $RESULTS | ConvertTo-Json

The response is a JSON object containing a list of individual incidents. Name is the name of the alert that created the incident.

{
  "incidents": [
    {
      "status": "close",
      "name": "ZK-1 heartbeat",
      "timestamp": "2019-05-23T16:42:24Z",
      "resolution_time": "2019-05-23T17:00:28Z",
      "alert_id": 4823,
      "condition": "Heartbeat: DOWN"
    }
  ],
  "deployment": "ss123456"
}

account > deployment > alerts > read

This method lists the threshold alerts for a deployment. (Alerts are threshold triggers that create incidents.)

GET https://app.searchstax.com/api/rest/v2/account/{account_name}/deployment/{uid}/alerts/

where <account_name> is the name of the tenant account, and <uid> is the ID of the deployment.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/alerts/" \
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$RESULTS = Invoke-RestMethod -Method Get -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/alerts/" 
$RESULTS = $RESULTS | ConvertTo-Json

The response is a JSON object containing a list of alerts and their properties.

{
  "alerts": [
    {
      "status": "enabled",
      "metric": "system_cpu_usage",
      "max_alerts": 1,
      "threshold": 80.0,
      "host": "ss123456-4",
      "delay_mins": 1,
      "operator": ">",
      "id": 2426,
      "unit": "percentage",
      "name": "High Solr CPU Usage",
      "repeat_every": 1,
      "email": "user@company.com"
    }
  ],
  "deployment": "ss123456"
}

account > deployment > alerts > create

This method creates a new alert in a deployment.

POST https://app.searchstax.com/api/rest/v2/account/{account_name}/deployment/{uid}/alerts/

where <account_name> is the name of the tenant account, and <uid> is the ID of the deployment.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "email":  [
                  "user@company.com"
              ],
    "webhook_trigger": 2,
    "webhook_resolve": 5,
    "max_alerts":  "2",
    "metric":  "system_cpu_usage",
    "delay_mins":  "1",
    "name":  "high cpu load",
    "threshold":  "90",
    "operator":  ">",
    "repeat_every":  "5",
    "host":  "*",
    "unit":  "percentage"
}
Parameter Description Example
name
required
string		 Name of the alert. “high cpu load”
metric
required
string		 The metric you wish to monitor. For available metrics, check the Account Alerts Metrics method. “system_cpu_usage”
threshold
required
string		 Alert triggers when it sees threshold events within delay_mins minutes. “90”
unit
required
string		 One of number/percentage/KB/MB/GB percentage
operator
required
string		 One of <,>,>=,<=,= “>”
email
optional
list of strings		 List of email addresses. Either an email or both webhook parameters are required. [“user@company.com”]
webhook_trigger
optional
integer		 The ID of the webhook to call when the alert is triggered. Either an email or both webhook parameters are required. 88
webhook_resolve
optional
integer		 The ID of the webhook to call when the alert is resolved. Either an email or both webhook parameters are required. 99
host
required
string		 Name of the server. Use * to create alerts for all hosts in the cluster. For the Total Requests metric, use the UID of the load balancer. “ss123456-1”
“*”
“ss123456-lb”
delay_mins
required
string		 Alert triggers when it sees threshold events within delay_mins minutes. “5”
max_alerts
required
string		 Maximum number of alerts for this metric. “2”
repeat_every
required
string		 Time interval in mins after which the alert should reset. “10”

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/alerts/" \
  --header "Authorization: Token <token>" \
  --header "Content-Type: application/json" \
  --data {
    \"email\": [ \"user@company.com\" ],
    \"max_alerts\":  \"2\",
    \"metric\":  \"system_cpu_usage\",
    \"delay_mins\":  \"1\",
    \"name\":  \"high cpu load\",
    \"threshold\":  \"90\",
    \"operator\":  \">\",
    \"repeat_every\":  \"5\",
    \"host\":  \"*\",
    \"unit\":  \"percentage\"
}

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    name='High Disk Usage'
    metric='system_disk_space_used'
    threshold='50'
    unit='GB'
    operator='>'
    host='*'
    delay_mins='1'
    max_alerts='2'
    repeat_every='5'
    email=@('user@company.com')
    webhook_trigger=2
    webhook_resolve=5
}

$body = $body | ConvertTo-Json

$RESULTS = Invoke-RestMethod -Method Post -Body $body -ContentType 'application/json' -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/alerts/" 
$RESULTS = $RESULTS | ConvertTo-Json

The response is a JSON object containing a simple message.

{
    "message":  "Success!"
}

account > deployment > alerts > update

This method enables or disables an alert (or all alerts) by updating the status property.

PUT /api/rest/v2/account/<account_name>/deployment/<uid>/alerts/<id>|all/

where <account_name> is the name of the tenant account, <uid> is the ID of the deployment, and <id> is the ID number of the alert or “all” to update all deployment alerts simultaneously.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "status":  "enable"
}
Parameter Description Example
status
required
string		 enable/disable “enable”

When invoked from Linux (Bash script):

curl --request PUT "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/alerts/<id>/" \
  --header "Authorization: Token <token>" \
  --header "Content-Type: application/json" \
  --data {
    \"status\":  \"enable\"
}

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"
$ALERTID = "2431"

$body = @{
    status='disable'
}

$body = $body | ConvertTo-Json

$RESULTS = Invoke-RestMethod -Method Put -body $body -ContentType 'application/json' -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/alerts/$ALERTID/" 
$RESULTS = $RESULTS | ConvertTo-Json

The response is a JSON object containing a simple message.

{
  "message": "Disabled alert High Disk Usage",
  "success": "true"
}

account > deployment > alerts > delete

This method deletes an alert (or all alerts) from a deployment.

DELETE /api/rest/v2/account/<account_name>/deployment/<uid>/alerts/<id>|all/

where <account_name> is the name of the tenant account, <uid> is the ID of the deployment, and <id> is the ID number of the alert or “all” to delete all alerts from the deployment.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request DELETE "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/alerts/<id>/" \
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"
$ALERTID = "2431"

$RESULTS = Invoke-RestMethod -Method Delete -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/alerts/$ALERTID/" 
$RESULTS = $RESULTS | ConvertTo-Json

The response is a JSON object containing a simple message.

{
    "message":  "Successfully deleted alert Idle System",
    "success":  "true"
}

account > deployment > alerts > heartbeat > list

This method lists all of the heartbeat alerts for a deployment, along with their properties.

GET /api/rest/v2/account/<account_name>/deployment/<uid>/alerts/heartbeat/

where <account_name> is the name of the tenant account, and <uid> is the ID of the deployment.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/alerts/heartbeat/" \
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$RESULTS = Invoke-RestMethod -Method Get -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/alerts/heartbeat/" 
$RESULTS = $RESULTS | ConvertTo-Json

The response is a JSON document containing a list of heartbeat alerts and their properties.

{
  "alerts": [
    {
      "status": "enabled",
      "host": "ss123456-1",
      "name": "ZK-1 Heartbeat",
      "interval": 5,
      "id": 341,
      "max_alerts": 1,
      "email": "user@company.com"
    }
  ],
  "deployment": "ss123456"
}

account > deployment > alerts > heartbeat > create

This method creates a heartbeat alert in a deployment.

POST /api/rest/v2/account/<account_name>/deployment/<uid>/alerts/heartbeat/

where <account_name> is the name of the tenant account, and <uid> is the ID of the deployment.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "email":  [ "user@company.com" ],
    "name":  "Heartbeat from API",
    "host":  "*",
    "max_alerts":  "5",
    "interval":  "5",
    "webhook_trigger": 2,
    "webhook_resolve": 5
}
Parameter Description Example
name
required
string		 This is the name of the heartbeat alert. “Test Heartbeat”
host
required
string		 This is the host ID, identifying one of the servers of the cluster. Use “*” to place the same alert on all of the cluster’s servers. “ss123456-1” or “*”
interval
required
string		 The number of minutes in the sampling window. The alert will be triggered when SearchStax sees X failures within an Interval of X minutes. Accepts only multiples of 5 minutes up to 30. “5”
max_alerts
required
string		 The maximum number of emails to send about an incident. “5”
email
optional
list of strings		 List of email addresses. Either an email or both webhook parameters are required. [“user@company.com”]
webhook_trigger
optional
integer		 The ID of the webhook to call when the alert is triggered. Either an email or both webhook parameters are required. 88
webhook_resolve
optional
integer		 The ID of the webhook to call when the alert is resolved. Either an email or both webhook parameters are required. 99

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/alerts/" \
  --header "Authorization: Token <token>" \
  --header "Content-Type: application/json" \
  --data {
    \"email\": [ \"user@company.com\" ],
    \"max_alerts\":  \"5\",
    \"interval\":  \"5\",
    \"name\":  \"Heartbeat from API\",
    \"host\":  \"*\",
}

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    name='Heartbeat from API'
    host='*'
    interval='5'
    max_alerts='5'
    email=@('user@company.com')
    webhook_trigger=2
    webhook_resolve=5
}

$body = $body | ConvertTo-Json

$RESULTS = Invoke-RestMethod -Method Post -Body $body -ContentType 'application/json' -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/alerts/heartbeat/" 
$RESULTS = $RESULTS | ConvertTo-Json

The response is a JSON document containing a simple success/failure message.

{
    "message":  "Success!"
}

account > deployment > alerts > heartbeat > read

This method retrieves the properties of a heartbeat alert from its ID number.

GET /api/rest/v2/account/<account_name>/deployment/<uid>/alerts/heartbeat/<id>/

where <account_name> is the name of the tenant account, <uid> is the ID of the deployment, and <id> is the ID of the alert. You can obtain the ID from the heartbeat list method.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/alerts/heartbeat/<id>/" \
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"
$ALERTID = "2431"

$RESULTS = Invoke-RestMethod -Method Get -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/alerts/heartbeat/$ALERTID/" 
$RESULTS = $RESULTS | ConvertTo-Json

The response is a JSON document containing the properties of a single heartbeat alert:

{
  "status": "enabled",
  "host": "ss123456-1",
  "name": "ZK-1 Heartbeat",
  "interval": 5,
  "id": 341,
  "max_alerts": 1,
  "email": [
    "user@company.com"
  ]
}

account > deployment > alerts > heartbeat > update

This method enables/disables heartbeat alerts.

PUT /api/rest/v2/account/<account_name>/deployment/<uid>/alerts/heartbeat/<id>/

where <account_name> is the name of the tenant account, <uid> is the ID of the deployment, and <id> is the ID of the alert or “all”. You can obtain the ID from the heartbeat list method.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "status":  "disable"
}
Parameter Description Example
status
required
string		 enable/disable “enable”

When invoked from Linux (Bash script):

curl --request PUT "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/alerts/heartbeat/<id>/" \
  --header "Authorization: Token <token>" \
  --header "Content-Type: application/json" \
  --data {
    \"status\":  \"enable\"
}

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"
$ALERTID = "2431"

$body = @{
    status='disable'
}

$body = $body | ConvertTo-Json

$RESULTS = Invoke-RestMethod -Method Put -body $body -ContentType 'application/json' -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/alerts/heartbeat/$ALERTID/" 
$RESULTS = $RESULTS | ConvertTo-Json

The response is a JSON document describing the success of the action.

{
  "message": "Disabled heartbeat alert for ss123456",
  "success": "true"
}

account > deployment > alerts > heartbeat > delete

This method deletes one or all heartbeat alerts from a deployment.

DELETE /api/rest/v2/account/<account_name>/deployment/<uid>/alerts/heartbeat/<id>/

where <account_name> is the name of the tenant account, <uid> is the ID of the deployment, and <id> is the ID of the alert or “all”. You can obtain the ID from the heartbeat list method.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request DELETE "https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/alerts/heartbeat/<id>/" \
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"
$ALERTID = "2431"

$RESULTS = Invoke-RestMethod -Method Delete -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/alerts/heartbeat/$ALERTID/" 
$RESULTS = $RESULTS | ConvertTo-Json

The response is a JSON document confirming the success of the deletion.

{
    "message":  "Successfully deleted all heartbeat alerts for ss123456",
    "success":  "true"
}

Questions?

Do not hesitate to contact the SearchStax Support Desk.

The post Solr Alerts API appeared first on SearchStax Docs.

]]> https://www.searchstax.com/docs/searchstax-cloud-alerts-api/feed/ 0 Solr Webhooks API https://www.searchstax.com/docs/searchstax-cloud-webhooks-api/ https://www.searchstax.com/docs/searchstax-cloud-webhooks-api/#respond Thu, 04 Mar 2021 07:20:29 +0000 https://www.searchstax.com/docs/?p=7564 Provisioning API – Webhooks Overview The SearchStax Managed Search service provides an API supporting the creation, deletion and management of Managed Search deployments. Core and Enterprise Clients Only! The… Continue reading Solr Webhooks API

The post Solr Webhooks API appeared first on SearchStax Docs.

]]> Provisioning API – Webhooks

Overview

The SearchStax Managed Search service provides an API supporting the creation, deletion and management of Managed Search deployments.

Core and Enterprise Clients Only!

The SearchStax API suite is available to our Core and Enterprise clients only, as noted on our Pricing page.

This page describes how to view webhooks using API methods.

The API can be accessed through any tool that assembles HTTP requests and dispatch them to a server. Among these would be the Python coreapi package, the Postman tool, and cURL. For Windows, use PowerShell 7+.

Account Owner, Admin, or Technical Contact

To run the SearchStax Provisioning API, you must be the account Owner, an account Admin, or a Technical Contact. See SearchStax User Roles.

Symbols enclosed in carets (< and >) such as <username> are metavariables. Substitute your local values when you encounter them in the examples.

Contents:

Related Pages:

Webhooks

The Provisioning API includes a method for listing the webhooks that have been created through the SearchStax dashboard. This provides the webhook IDs that can be optionally included when creating threshold and heartbeat alerts.

account > webhook > list

This method lists all of the webhooks for a deployment, along with their properties.

GET /api/rest/v2/account/<account_name>/webhook/

where <account_name> is the name of the tenant account.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account/<account_name>/webhook/" \
  --header "Authorization: Token <token>"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"

$RESULTS = Invoke-RestMethod -Method Get -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/webhook/" 
$RESULTS = $RESULTS | ConvertTo-Json

The response is a JSON document containing a list of webhooks and their properties.

{
  "results": [
    {
      "id": 7,
      "account": "AccountName",
      "payload": {
        "alertThresholdValue_ws": "§§$ALERT_THRESHOLD_VALUE§§",
        "alertRuleName_ws": "§§$ALERT_TITLE§§",
        "metric_ws": "§§$ALERT_METRIC§§",
        "alertThresholdOperator_ws": "§§$ALERT_THRESHOLD_OPERATOR§§",
        "alertid_ws": "§§$ALERT_ID§§",
        "deployment_id_ws": "§§$DEPLOYMENT_UID§§",
        "deployment_ws": "§§$DEPLOYMENT_NAME§§",
        "host_ws": "§§$HOSTNAME§§",
        "alert_status_ws": "none",
        "alertTimeInUTC_ws": "§§$DATE§§",
        "value_ws": "§§$ALERT_CURRENT_VALUE§§",
        "alertStatus_ws": "§§$ALERT_STATUS§§"
      },
      "custom_headers": {},
      "created": "2020-01-27T18:05:00.516230Z",
      "updated": null,
      "name": "webhookInput",
      "url": "https://ss123456-l70y8miq-eastus-azure.searchstax.co/solr/webhookInput/update",
      "url_ssl_ignore": true,
      "encode_as_form": false,
      "paused": true
    }
  ]
}

Questions?

Do not hesitate to contact the SearchStax Support Desk.

The post Solr Webhooks API appeared first on SearchStax Docs.

]]> https://www.searchstax.com/docs/searchstax-cloud-webhooks-api/feed/ 0