For clean Markdown of any page, append .md to the page URL. For a complete documentation index, see https://api-doc-new.gideononline.com/gideon-api-1-0/search/llms.txt. For full documentation content, see https://api-doc-new.gideononline.com/gideon-api-1-0/search/llms-full.txt.

# /search/suggestions

GET https://api.gideononline.com/search/suggestions

This endpoint returns list of suggestions that are possible matches for an incomplete search query. This enables you to display likely matches before users finish typing their queries. 

The logics behind providing suggestions are:
- word prefix matching
- fuzzy matching (attempts to find a match even after one or more typos in the searched prefix). This may be useful since medical terms are often difficult to spell correctly.




Reference: https://api-doc-new.gideononline.com/gideon-api-1-0/search/search-suggestions

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: collection
  version: 1.0.0
paths:
  /search/suggestions:
    get:
      operationId: search-suggestions
      summary: /search/suggestions
      description: >+
        This endpoint returns list of suggestions that are possible matches for
        an incomplete search query. This enables you to display likely matches
        before users finish typing their queries. 


        The logics behind providing suggestions are:

        - word prefix matching

        - fuzzy matching (attempts to find a match even after one or more typos
        in the searched prefix). This may be useful since medical terms are
        often difficult to spell correctly.


      tags:
        - subpackage_search
      parameters:
        - name: q
          in: query
          description: String. Terms to search
          required: false
          schema:
            type: string
        - name: Authorization
          in: header
          required: true
          schema:
            type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Search_/search/suggestions_Response_200'
servers:
  - url: https://api.gideononline.com
  - url: https://api-test.gideononline.com
components:
  schemas:
    Search_/search/suggestions_Response_200:
      type: object
      properties:
        data:
          type: array
          items:
            type: string
      required:
        - data
      title: Search_/search/suggestions_Response_200
  securitySchemes:
    apiKeyAuth:
      type: apiKey
      in: header
      name: Authorization

```

## SDK Code Examples

```python Search_/search/suggestions_example
import requests

url = "https://api.gideononline.com/search/suggestions"

querystring = {"q":"Required"}

headers = {"Authorization": "<apiKey>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

```javascript Search_/search/suggestions_example
const url = 'https://api.gideononline.com/search/suggestions?q=Required';
const options = {method: 'GET', headers: {Authorization: '<apiKey>'}};

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

```go Search_/search/suggestions_example
package main

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

func main() {

	url := "https://api.gideononline.com/search/suggestions?q=Required"

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

	req.Header.Add("Authorization", "<apiKey>")

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

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

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

}
```

```ruby Search_/search/suggestions_example
require 'uri'
require 'net/http'

url = URI("https://api.gideononline.com/search/suggestions?q=Required")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = '<apiKey>'

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

```java Search_/search/suggestions_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.gideononline.com/search/suggestions?q=Required")
  .header("Authorization", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.gideononline.com/search/suggestions?q=Required', [
  'headers' => [
    'Authorization' => '<apiKey>',
  ],
]);

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

```csharp Search_/search/suggestions_example
using RestSharp;

var client = new RestClient("https://api.gideononline.com/search/suggestions?q=Required");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Search_/search/suggestions_example
import Foundation

let headers = ["Authorization": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.gideononline.com/search/suggestions?q=Required")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()
```