API REST OSINT

http://100.80.6.13:8000

X-API-Key: votre_cle_api

Authorization: Bearer votre_cle_api

curl http://100.80.6.13:8000/health

pip install requests

import requests

API_URL = "http://100.80.6.13:8000"
API_KEY = "votre_cle_api"

response = requests.post(
    f"{API_URL}/search",
    headers={"X-API-Key": API_KEY},
    json={
        "prenom": "Jean",
        "nom": "Dupont"
    }
)

data = response.json()
print(f"Résultats trouvés : {data['total_results']}")

for result in data["results"]:
    print(f"  [{result['score']:.1f}] {result['url']}")

import requests
from requests.exceptions import RequestException

class OsintClient:
    def __init__(self, api_key: str, base_url: str = "http://100.80.6.13:8000"):
        self.base_url = base_url
        self.session = requests.Session()
        self.session.headers.update({"X-API-Key": api_key})

    def search(self, **criteria) -> dict:
        try:
            r = self.session.post(
                f"{self.base_url}/search",
                json=criteria,
                timeout=30
            )
            r.raise_for_status()
            return r.json()
        except requests.HTTPError as e:
            err = e.response.json().get("error", str(e))
            raise ValueError(f"API error {e.response.status_code}: {err}")

# Utilisation
client = OsintClient("votre_cle_api")

results = client.search(
    prenom="Jean",
    nom="Dupont",
    email="jean.dupont@example.com",
    ville="Paris",
    pays="France",
    max_results=50
)

print(f"✓ {results['total_results']} résultats en {results['processing_time_seconds']:.2f}s")

for r in results["results"][:5]:  # Top 5
    print(f"  [{r['score']:5.1f}] {r['title']}")
    print(f"         {r['url']}")

const API_URL = "http://100.80.6.13:8000"
const API_KEY = "votre_cle_api"

const searchOsint = async (criteria) => {
  const response = await fetch(`${API_URL}/search`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-Key": API_KEY
    },
    body: JSON.stringify(criteria)
  })

  if (!response.ok) {
    const err = await response.json()
    throw new Error(`API ${response.status}: ${err.error}`)
  }

  return response.json()
}

// Exemple d'utilisation
const results = await searchOsint({
  prenom: "Jean",
  nom: "Dupont",
  email: "jean.dupont@example.com",
  ville: "Paris",
  max_results: 50
})

console.log(`✓ ${results.total_results} résultats`)
results.results.slice(0, 5).forEach((r) => {
  console.log(`  [${r.score.toFixed(1)}] ${r.url}`)
})

interface SearchCriteria {
  prenom?: string
  nom?: string
  telephone?: string
  email?: string
  adresse?: string
  ville?: string
  code_postal?: string
  pays?: string
  max_results?: number
}

interface SearchResult {
  score: number
  url: string
  title: string
  description: string
  engine: string
  matched_queries_count: number
  matched_fields: string[]
  queries: string[]
}

interface SearchResponse {
  success: boolean
  total_results: number
  queries_generated: number
  processing_time_seconds: number
  results: SearchResult[]
}

class OsintClient {
  private baseUrl: string
  private apiKey: string

  constructor(apiKey: string, baseUrl = "http://100.80.6.13:8000") {
    this.apiKey = apiKey
    this.baseUrl = baseUrl
  }

  async search(criteria: SearchCriteria): Promise<SearchResponse> {
    const res = await fetch(`${this.baseUrl}/search`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "X-API-Key": this.apiKey
      },
      body: JSON.stringify(criteria)
    })

    const json = await res.json()
    if (!res.ok) throw new Error(json.error)
    return json
  }

  async health(): Promise<boolean> {
    const res = await fetch(`${this.baseUrl}/health`)
    return res.ok
  }
}

// Usage
const client = new OsintClient("votre_cle_api")
const data = await client.search({ prenom: "Jean", nom: "Dupont" })