Documentation

const axios = require('axios');

async function reconcile() {
  const url = 'https://api.similarity-api.com/reconcile';
  const token = process.env.SIMILARITY_API_KEY; 

  const payload = {
    data_a: ['Microsoft', 'appLE'],
    data_b: ['Apple Inc.', 'Microsoft'],
    config: {
      similarity_threshold: 0.75,
      top_n: 10,
      remove_punctuation: true,
      to_lowercase: true,
      use_token_sort: true,
      output_format: 'flat_table'
    }
  };

  try {
    const res = await axios.post(url, payload, {
      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' }
    });
    console.log('Reconcile results:', res.data);
  } catch (err) {
    console.error('Error:', err.response?.data || err.message);
  }
}

reconcile();

import os, requests, json

url = "https://api.similarity-api.com/reconcile"
token = os.getenv("SIMILARITY_API_KEY")

headers = {
    "Authorization": f"Bearer {token}",
    "Content-Type": "application/json"
}

payload = {
    "data_a": ["Microsoft", "appLE"],
    "data_b": ["Apple Inc.", "Microsoft"],
    "config": {
        "similarity_threshold": 0.75,
        "top_n": 10,
        "remove_punctuation": True,
        "to_lowercase": True,
        "use_token_sort": True,
        "output_format": "flat_table"
    }
}

try:
    r = requests.post(url, headers=headers, json=payload, timeout=60)
    r.raise_for_status()
    print(json.dumps(r.json(), indent=2))
except requests.HTTPError as e:
    print("HTTP error:", r.status_code, r.text)
except Exception as e:
    print("Error:", str(e))

import java.io.IOException;
import java.net.http.*;
import java.net.URI;
import java.time.Duration;

public class ReconcileExample {
  public static void main(String[] args) throws Exception {
    String url = "https://api.similarity-api.com/reconcile";
    String token = System.getenv("SIMILARITY_API_KEY");

    String json = """
      {
        "data_a": ["Microsoft", "appLE"],
        "data_b": ["Apple Inc.", "Microsoft"],
        "config": {
          "similarity_threshold": 0.75,
          "top_n": 10,
          "remove_punctuation": true,
          "to_lowercase": true,
          "use_token_sort": true,
          "output_format": "flat_table"
        }
      }
      """;

    HttpClient client = HttpClient.newHttpClient();
    HttpRequest req = HttpRequest.newBuilder()
        .uri(URI.create(url))
        .timeout(Duration.ofSeconds(60))
        .header("Authorization", "Bearer " + token)
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(json))
        .build();

    HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
    if (res.statusCode() >= 200 && res.statusCode() < 300) {
      System.out.println(res.body());
    } else {
      System.err.println("Error " + res.statusCode() + ": " + res.body());
    }
  }
}

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"time"
)

func main() {
	url := "https://api.similarity-api.com/reconcile"
	token := os.Getenv("SIMILARITY_API_KEY")

	payload := map[string]interface{}{
		"data_a": []string{"Microsoft", "appLE"},
		"data_b": []string{"Apple Inc.", "Microsoft"},
		"config": map[string]interface{}{
			"similarity_threshold": 0.75,
			"top_n":               10,
			"remove_punctuation":  true,
			"to_lowercase":        true,
			"use_token_sort":      true,
			"output_format":       "flat_table",
		},
	}

	body, _ := json.Marshal(payload)

	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(body))
	req.Header.Set("Authorization", "Bearer "+token)
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{Timeout: 60 * time.Second}
	res, err := client.Do(req)
	if err != nil {
		fmt.Println("Request error:", err)
		return
	}
	defer res.Body.Close()

	var out map[string]interface{}
	if err := json.NewDecoder(res.Body).Decode(&out); err != nil {
		fmt.Println("Decode error:", err)
		return
	}

	if res.StatusCode >= 200 && res.StatusCode < 300 {
		pretty, _ := json.MarshalIndent(out, "", "  ")
		fmt.Println(string(pretty))
	} else {
		fmt.Printf("Error %d: %v\n", res.StatusCode, out)
	}
}

const axios = require('axios');

(async () => {
  const res = await axios.post(
    'https://api.similarity-api.com/dedupe',
    {
      data: [
        'Apple Inc',
        'Apple Inc.',
        'Apple Incorporated',
        'Microsoft Corporation',
        'Microsoft Corp'
      ],
      config: {
        similarity_threshold: 0.85,
        remove_punctuation: false,
        to_lowercase: false,
        use_token_sort: false,
        output_format: 'index_pairs'
      }
    },
    { headers: { Authorization: `Bearer ${process.env.SIMILARITY_API_KEY}` } }
  );
  console.log(res.data);
})();

import os, requests, json

url = "https://api.similarity-api.com/dedupe"
token = os.getenv("SIMILARITY_API_KEY")

headers = {
    "Authorization": f"Bearer {token}",
    "Content-Type": "application/json"
}

payload = {
    "data": [
        "Apple Inc",
        "Apple Inc.",
        "Apple Incorporated",
        "Microsoft Corporation",
        "Microsoft Corp"
    ],
    "config": {
        "similarity_threshold": 0.85,
        "remove_punctuation": False,
        "to_lowercase": False,
        "use_token_sort": False,
        "output_format": "index_pairs"
    }
}

try:
    r = requests.post(url, headers=headers, json=payload, timeout=60)
    r.raise_for_status()
    print(json.dumps(r.json(), indent=2))
except requests.HTTPError as e:
    print("HTTP error:", r.status_code, r.text)
except Exception as e:
    print("Error:", str(e))

import java.io.IOException;
import java.net.http.*;
import java.net.URI;
import java.time.Duration;

public class DedupeExample {
  public static void main(String[] args) throws Exception {
    String url = "https://api.similarity-api.com/dedupe";
    String token = System.getenv("SIMILARITY_API_KEY");

    String json = """
      {
        "data": [
          "Apple Inc",
          "Apple Inc.",
          "Apple Incorporated",
          "Microsoft Corporation",
          "Microsoft Corp"
        ],
        "config": {
          "similarity_threshold": 0.85,
          "remove_punctuation": false,
          "to_lowercase": false,
          "use_token_sort": false,
          "output_format": "index_pairs"
        }
      }
      """;

    HttpClient client = HttpClient.newHttpClient();
    HttpRequest req = HttpRequest.newBuilder()
        .uri(URI.create(url))
        .timeout(Duration.ofSeconds(60))
        .header("Authorization", "Bearer " + token)
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(json))
        .build();

    HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
    if (res.statusCode() >= 200 && res.statusCode() < 300) {
      System.out.println(res.body());
    } else {
      System.err.println("Error " + res.statusCode() + ": " + res.body());
    }
  }
}

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
)

func main() {
	// Build request body
	requestBody, _ := json.Marshal(map[string]interface{}{
		"data": []string{
			"Apple Inc",
			"Apple Inc.",
			"Apple Incorporated",
			"Microsoft Corporation",
			"Microsoft Corp",
		},
		"config": map[string]interface{}{
			"similarity_threshold": 0.85,
			"remove_punctuation":  false,
			"to_lowercase":        false,
			"use_token_sort":      false,
			"output_format":       "index_pairs", // or "string_pairs", "deduped_strings", "deduped_indices"
		},
	})

	// Create request
	req, _ := http.NewRequest("POST", "https://api.similarity-api.com/dedupe", bytes.NewBuffer(requestBody))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+os.Getenv("SIMILARITY_API_KEY")) // <-- Bearer header

	// Send request
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Error sending request:", err)
		return
	}
	defer resp.Body.Close()

	// Read response
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}