Développeurs
Intégrez Refine à l’aide de son API REST ou connectez des outils d’IA via le Model Context Protocol (MCP)
MCP
Model Context Protocol (MCP)
MCP est un standard ouvert qui permet aux assistants IA d’interagir directement avec des outils et des sources de données externes. Connectez votre outil d’IA préféré à Refine avec un seul endpoint.
- Ajoutez l’URL de l’endpoint MCP de Refine à la configuration de votre outil d’IA
- Votre outil prendra automatiquement en charge l’authentification OAuth
Vous utilisez Claude sur le Web, sur ordinateur ou mobile ? Installez le connecteur Refine directement depuis le catalogue Claude, sans configuration à copier-coller.
Ouvrir le connecteur Refine{
"mcpServers": {
"refine": {
"url": "https://api.refine.ink/mcp"
}
}
}{
"mcpServers": {
"refine": {
"url": "https://api.refine.ink/mcp"
}
}
}{
"servers": {
"refine": {
"type": "http",
"url": "https://api.refine.ink/mcp"
}
}
}OAuth est la méthode d’authentification par défaut. Votre client MCP gérera automatiquement le flux d’autorisation.
MCP peut aussi utiliser des clés API pour s’authentifier.
REST API
REST API
Une API RESTful avec une documentation OpenAPI interactive. Explorez tous les endpoints disponibles, les schémas de requête et de réponse, et testez directement des requêtes depuis votre navigateur.
Voir la documentation API- Créez une clé API dans Paramètres avancés du compte, sur votre page de profil
- Utilisez la clé pour authentifier vos requêtes
# 1. Upload a document
UPLOAD=$(curl -s -X POST "https://api.refine.ink/documents/upload" \
-H "X-API-Key: your-api-key" \
-F "file=@paper.pdf")
TASK_ID=$(echo $UPLOAD | jq -r '.task_id')
# 2. Wait for upload processing via SSE
curl -N "https://api.refine.ink/documents/upload/events/$TASK_ID?token=your-api-key"
# Listen until you receive: event: complete, data: {"document_id": "..."}
DOCUMENT_ID="<document_id from SSE>"
# 3. Start document processing (costs 1 credit)
PROCESS=$(curl -s -X POST "https://api.refine.ink/documents/$DOCUMENT_ID/process" \
-H "X-API-Key: your-api-key" \
-H "Content-Type: application/json" \
-d '{"preview": false}')
SESSION_ID=$(echo $PROCESS | jq -r '.session_id')
# 4. Stream processing progress via SSE
curl -N "https://api.refine.ink/documents/$DOCUMENT_ID/process/events/$SESSION_ID?token=your-api-key"import requests
import sseclient # pip install sseclient-py
API_KEY = "your-api-key"
BASE = "https://api.refine.ink"
headers = {"X-API-Key": API_KEY}
# 1. Upload a document
with open("paper.pdf", "rb") as f:
upload = requests.post(
f"{BASE}/documents/upload",
headers=headers,
files={"file": f}
).json()
task_id = upload["task_id"]
# 2. Wait for upload processing via SSE
response = requests.get(
f"{BASE}/documents/upload/events/{task_id}?token={API_KEY}",
stream=True
)
client = sseclient.SSEClient(response)
for event in client.events():
if event.event == "complete":
document_id = json.loads(event.data)["document_id"]
break
# 3. Start document processing (costs 1 credit)
process = requests.post(
f"{BASE}/documents/{document_id}/process",
headers=headers,
json={"preview": False}
).json()
session_id = process["session_id"]
# 4. Stream processing progress via SSE
response = requests.get(
f"{BASE}/documents/{document_id}/process/events/{session_id}?token={API_KEY}",
stream=True
)
for event in sseclient.SSEClient(response).events():
print(event.event, event.data)const API_KEY = "your-api-key";
const BASE = "https://api.refine.ink";
// 1. Upload a document
const form = new FormData();
form.append("file", new Blob([fileBuffer]), "paper.pdf");
const upload = await fetch(`${BASE}/documents/upload`, {
method: "POST",
headers: { "X-API-Key": API_KEY },
body: form,
}).then(r => r.json());
const taskId = upload.task_id;
// 2. Wait for upload processing via SSE
const uploadEvents = new EventSource(
`${BASE}/documents/upload/events/${taskId}?token=${API_KEY}`
);
const documentId = await new Promise<string>((resolve) => {
uploadEvents.addEventListener("complete", (e) => {
resolve(JSON.parse(e.data).document_id);
uploadEvents.close();
});
});
// 3. Start document processing (costs 1 credit)
const process = await fetch(
`${BASE}/documents/${documentId}/process`,
{
method: "POST",
headers: {
"X-API-Key": API_KEY,
"Content-Type": "application/json",
},
body: JSON.stringify({ preview: false }),
}
).then(r => r.json());
// 4. Stream processing progress via SSE
const processEvents = new EventSource(
`${BASE}/documents/${documentId}/process/events/${process.session_id}?token=${API_KEY}`
);
// Events are named, so listen per event rather than on "message"
processEvents.addEventListener("progress", (e) => {
console.log(JSON.parse(e.data));
});
processEvents.addEventListener("complete", (e) => {
console.log(JSON.parse(e.data));
processEvents.close();
});Protégez vos clés API. Ne les ajoutez pas à votre système de contrôle de version et ne les exposez pas dans du code côté client.
Tests
Testez votre intégration
Vous n’avez pas besoin de dépenser des crédits pour développer avec Refine. Simulez l’API à partir de notre schéma OpenAPI pendant que vous mettez votre intégration en place, puis passez au pipeline réel quand vous êtes prêt.
Simulez l’API à partir du schéma OpenAPI
Chaque endpoint est décrit dans notre schéma OpenAPI. Tout outil de simulation qui lit OpenAPI peut mettre en place une fausse API Refine pour vous : Prism, Mockoon, Microcks, WireMock, Postman ou le serveur de simulation de votre framework. Configurez votre client pour l’utiliser et testez votre code d’importation, de traitement et d’interrogation répétée de l’état d’avancement, sans toucher au service réel.
# Grab the OpenAPI schema
curl -o refine-openapi.json https://api.refine.ink/openapi.json
# Serve a mock from it with the tool of your choice, e.g. Prism
npx @stoplight/prism-cli mock refine-openapi.json
# Point your client at the mock instead of the real API
export REFINE_API_URL=http://127.0.0.1:4010Le schéma est toujours synchronisé avec l’API en production : Voir le schéma OpenAPI.
Ou testez le flux réel
Les simulations ne peuvent pas vous montrer à quoi ressemblent les vrais commentaires. Contactez-nous et nous attribuerons des crédits d’aperçu à votre compte pour que vous puissiez faire passer de vrais documents dans le pipeline complet. Les aperçus sont rapides et nécessitent peu de traitement ; ils renvoient donc moins de commentaires qu’une relecture complète, suffisamment pour valider votre intégration de bout en bout.
Contactez-nous pour demander des crédits d’aperçuCommencez à coder
Les API destinées aux développeurs sont en bêta, et vos retours sont les bienvenus pendant que nous continuons à les développer.