SDKs

Reference

Caution

All the SDKs are automatically generated by OpenAPI, and are currently in beta

Naurt offers SDKs in several languages to help speed up integration. The following table shows the available SDKs.

Language	Link
Rust	https://crates.io/crates/naurt-api
Python	https://pypi.org/project/naurt-api/
Go	https://github.com/Naurt-Ltd/api_specification
TypeScript/JavaScript	https://www.npmjs.com/package/@naurt/api

Here’s how to use the SDKS

1. Import the library

   Rust

   Include the following in the Cargo.toml

   [dependencies]
   naurt-api = "0.1.0"

   Python

   Install with pip

   pip install naurt-api

   TypeScript

   Install with npm

   npm i @naurt/api

   JavaScript

   Install with npm

   npm i @naurt/api

   Go

   Install with go

   go get github.com/Naurt-Ltd/api_specification/generated/go@v0.1.0

2. Configure a simple request

   Rust

   use std::fs;
   
   use naurt_api::{
       apis::{
           configuration::{ApiKey, Configuration},
           final_destination_api::finaldestination_post,
       },
       models::{FinalDestinationOptions, FinalDestinationQuery, FinalDestinationRequest},
   };
   use reqwest::Client;
   
   #[tokio::main]
   async fn main() {
       let api_key = fs::read_to_string("api.key").unwrap();
   
       let req = FinalDestinationRequest {
           queries: vec![FinalDestinationQuery {
               address_string: Some("47 Digby Rd, Evesham WR11 1BW".to_string()),
               ..Default::default()
           }],
           options: Some(Box::new(FinalDestinationOptions {
               pretty_print: Some(true),
               ..Default::default()
           })),
       };
   
       let client = Client::new();
   
       let api_key = ApiKey {
           key: api_key,
           prefix: None,
       };
   
       let config = Configuration {
           api_key: Some(api_key),
           base_path: "https://api.naurt.net".to_string(),
           client: client,
           ..Default::default()
       };
   
       let resp = finaldestination_post(&config, req).await.unwrap();
   
       println!("{:?}", resp);
   }

   Python

   from naurt_api import AuthenticatedClient
   from naurt_api.api.final_destination import finaldestination_post
   import naurt_api.models as naurt_models
   
   f = open("api.key", "r")
   API_KEY = f.read()
   f.close()
   
   def main():
     client = AuthenticatedClient(
       base_url="https://api.naurt.net",
       token=API_KEY,
       prefix="" # NOTE: This is important
     )
   
     query = naurt_models.FinalDestinationQuery(address_string="47 Digby Rd, Evesham WR11 1BW")
   
     request = naurt_models.FinalDestinationRequest(queries=[query])
   
     response = finaldestination_post.sync(client=client, body=request)
   
     print(response)
   
   
   if __name__ == "__main__":
     main()

   TypeScript

   import {
     Configuration,
     FinalDestinationApi,
     FinalDestinationRequest,
     FinalDestinationResponse,
     ResponseError,
   } from "@naurt/api";
   import * as fs from "fs";
   
   const apiKey = fs.readFileSync("api.key", "utf-8").trim();
   
   const config = new Configuration({
     basePath: "https://api.naurt.net",
     apiKey: async (name: string): Promise<string | undefined> => {
       if (name === "Authorization") {
         return apiKey;
       }
       return undefined;
     },
   });
   
   const api = new FinalDestinationApi(config);
   
   async function main(): Promise<void> {
     const request: FinalDestinationRequest = {
       queries: [
         {
           addressString: "447 Digby Rd, Evesham WR11 1BW",
         },
       ],
     };
   
     try {
       const raw = await api.finaldestinationPostRaw({
         finalDestinationRequest: request,
       });
   
       const data: FinalDestinationResponse = await raw.value();
       console.log(JSON.stringify(data, null, 2));
     } catch (err: unknown) {
       console.error("error:", err);
   
       if (err instanceof ResponseError) {
         const text = await err.response.text();
         console.error("raw body:", text);
         return;
       }
   
       if (
         typeof err === "object" &&
         err !== null &&
         "response" in err &&
         err.response instanceof Response
       ) {
         const text = await err.response.text();
         console.error("raw body:", text);
       }
     }
   }
   
   main().catch((err: unknown) => {
     console.error(err);
     process.exit(1);
   });

   JavaScript

   import { Configuration, FinalDestinationApi } from "@naurt/api";
   
   const fs = require('fs');
   
   
   const api_key = fs.readFileSync("api.key", "utf-8");
   
   const config = new Configuration({
     basePath: "https://api.naurt.net",
     apiKey: async (name) => {
       if (name === "Authorization") {
         return api_key
       }
       return undefined
     },
   });
   
   const api = new FinalDestinationApi(config);
   
   async function main() {
     try {
       const raw = await api.finaldestinationPostRaw({
         finalDestinationRequest: {
           queries: [
             {
               addressString: "447 Digby Rd, Evesham WR11 1BW",
             },
           ],
         },
       })
   
       const data = await raw.value()
       console.log(JSON.stringify(data, null, 2))
   
     } catch (err) {
       console.error("error:", err)
   
       if (err?.response) {
         const text = await err.response.text()
         console.error("raw body:", text)
       }
     }
   };
   
   main().catch((err) => {
     console.error(err)
     process.exit(1)
   });

   Go

   package main
   
   import (
     "context"
     "encoding/json"
     "fmt"
     "os"
   
     naurt "github.com/Naurt-Ltd/api_specification/generated/go"
   )
   
   func main() {
   
     api_key_b, err := os.ReadFile("api.key")
   
     if err != nil {
       panic(err)
     }
   
     api_key := string(api_key_b)
   
     cfg := naurt.NewConfiguration()
     cfg.Servers = naurt.ServerConfigurations{
       {
         URL: "https://api.naurt.net",
       },
     }
   
     client := naurt.NewAPIClient(cfg)
   
     ctx := context.WithValue(
       context.Background(),
       naurt.ContextAPIKeys,
       map[string]naurt.APIKey{
         "ApiKeyAuth": {Key: api_key, Prefix: ""}, // MUST be `ApiKeyAuth`, `Prefix: ""` is VERY important
       },
     )
   
     req := naurt.FinalDestinationRequest{
       Queries: []naurt.FinalDestinationQuery{
         {
           AddressString: naurt.PtrString("47 Digby Rd, Evesham WR11 1BW"),
         },
       },
       Options: nil,
     }
   
     resp, http, err := client.FinalDestinationAPI.FinaldestinationPost(ctx).FinalDestinationRequest(req).Execute()
   
     if err != nil {
       fmt.Println(http)
       panic(err)
     }
   
     fmt.Printf("%+v\n", http)
     fmt.Printf("%+v\n", resp)
   
     b, err := json.MarshalIndent(resp, "", "  ")
     if err != nil {
       panic(err)
     }
   
     fmt.Println(string(b))
   }

Need a language which we don’t officially support? You can contact us here. You can also use the OpenAPI specification at the repository to generate a repo in the language of your choice.