Recruiting Intelligence at the Speed of Code

# Chat con Rosy
curl -X POST https://api.bolsarosa.com/chat \
  -H "X-API-Key: sk_live_TU_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "Mejorar descripción de vacante Python senior",
    "session_id": "session_empresa_001"
  }'

# Matching de candidatas
curl -X POST https://api.bolsarosa.com/recommendations/candidates \
  -H "X-API-Key: sk_live_TU_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "vacancy_id": "vac_abc123",
    "user_type": "company",
    "limit": 5
  }'

# Verificar balance de tokens
curl https://api.bolsarosa.com/tokens/validate \
  -d '{"current_balance": 500, "operation": "chat"}'

import requests

class IntrareClient:
    BASE_URL = "https://api.bolsarosa.com"

    def __init__(self, api_key: str):
        self.headers = {
            "X-API-Key": api_key,
            "Content-Type": "application/json"
        }

    def chat(self, message: str, session_id=None):
        """Chat con Rosy — consumo dinamico calculado internamente."""
        payload = {"message": message}
        if session_id:
            payload["session_id"] = session_id
        r = requests.post(f"{self.BASE_URL}/chat",
                          headers=self.headers, json=payload)
        return r.json()["data"]

    def match_candidates(self, vacancy_id: str, limit=10):
        """AI matching de candidatas — consumo segun politica."""
        r = requests.post(f"{self.BASE_URL}/recommendations/candidates",
                          headers=self.headers,
                          json={"vacancy_id": vacancy_id,
                                "user_type": "company",
                                "limit": limit})
        return r.json()["data"]["recommendations"]

# Uso
client = IntrareClient("sk_live_abc123")
resp   = client.chat("Necesito mejorar el título de mi vacante")
print(resp["response"])

class IntrareService
{
    protected string $baseUrl = 'https://api.bolsarosa.com';
    protected string $apiKey;

    public function __construct()
    {
        $this->apiKey = config('services.intrare.api_key');
    }

    public function chat(string $message, ?string $sessionId = null): array
    {
        return Http::withHeaders(['X-API-Key' => $this->apiKey])
            ->post("{$this->baseUrl}/chat", [
                'message'    => $message,
                'session_id' => $sessionId,
            ])->json('data');
    }

    public function matchCandidates(string $vacancyId, int $limit = 5): array
    {
        return Http::withHeaders(['X-API-Key' => $this->apiKey])
            ->post("{$this->baseUrl}/recommendations/candidates", [
                'vacancy_id' => $vacancyId,
                'user_type'  => 'company',
                'limit'      => $limit,
            ])->json('data.recommendations', []);
    }
}

// Controller
$service  = new IntrareService();
$response = $service->chat('Mejorar título de la vacante de dev senior');

import axios from 'axios';

class IntrareClient {
  constructor(apiKey) {
    this.http = axios.create({
    baseURL: 'https://api.bolsarosa.com',
      headers: { 'X-API-Key': apiKey }
    });
  }

  async chat(message, sessionId = null) {
    const { data } = await this.http.post('/chat', { message, session_id: sessionId });
    return data.data;
  }

  async matchCandidates(vacancyId, limit = 10) {
    const { data } = await this.http.post('/recommendations/candidates', {
      vacancy_id: vacancyId, user_type: 'company', limit
    });
    return data.data.recommendations;
  }

  async improveVacancy(vacancyId, instruction) {
    const { data } = await this.http.post(`/vacancies/${vacancyId}/improve`,
      { request: instruction });
    return data.data; // { improvement_id, suggestions }
  }
}

// Usage
const client = new IntrareClient(process.env.INTRARE_API_KEY);
const resp   = await client.chat('Mejorar título de vacante Python');
console.log(resp.response);

Operación	Tokens	Nota

* En endpoints IA, el consumo real se calcula internamente con uso del modelo; si no hay uso reportado, aplica politica fallback.