Testeur d'API en masse
Testez des flottes d'API entières avec des suites réutilisables, une surveillance en direct et des crochets d'automatisation.
Loading development tool...
Testez des flottes d'API entières avec des suites réutilisables, une surveillance en direct et des crochets d'automatisation.
Loading development tool...
Exécutez des centaines d'appels REST, GraphQL ou gRPC en parallèle, capturez des données d'observabilité riches et transférez les requêtes échouées au Testeur d'API classique en un seul clic.
Travailleurs concurrents
Jusqu'à 100
Modèles de suite
Santé • Charge • Régression
Canaux d'alerte
Slack · PagerDuty · Webhooks
Composez des suites d'API multi-étapes, gérez les variables et exécutez-les avec une concurrence contrôlée.
Bulk execution uses the same public-host policy as API Tester. Localhost and private-network targets are blocked.
Définissez chaque requête dans la suite. Cochez la case pour ignorer temporairement un élément sans le supprimer.
Utilisez la syntaxe {{VARIABLE_NAME}} dans les URL, les en-têtes et les corps. Les valeurs sont injectées avant l'exécution.
Suivez l'achèvement, le taux de succès et les statistiques de latence pendant l'exécution de la suite.
Inspectez les codes de statut, les durées et les erreurs capturées pour chaque requête de la suite.
| Requête | Statut | Durée | Taille | Erreur |
|---|---|---|---|---|
| Exécutez la suite pour voir les résultats requête par requête ici. | ||||
Le Testeur d'API en masse étend le Testeur d'API à requête unique avec des outils pour l'exécution par lots, l'évaluation des performances et la surveillance de la production.
Exécutez des suites orchestrées qui mélangent des vérifications de santé, des flux de régression et des scénarios de stress.
Observez les graphiques de centiles, les tendances de débit et les taxonomies d'erreurs pendant l'exécution.
Promouvez les appels enregistrés du Testeur d'API en suites réutilisables sans reconstruire les en-têtes ou les préréglages d'authentification.
Utilisez le Testeur d'API original pour un débogage approfondi, puis faites évoluer les requêtes stables vers des suites en masse pour une validation à l'échelle de la flotte.
Discover→Combinez des suites planifiées avec des seuils d'alerte afin que les équipes de plateforme et SRE soient averties avant que les SLO ne dérivent.
Tout ce dont les équipes ont besoin pour passer des vérifications de points de terminaison ad hoc à une observabilité API disciplinée.
Regroupez les points de terminaison par parcours, héritez des variables partagées et enchaînez les requêtes dépendantes avec des extractions de réponse.
Ajustez les pools de travailleurs, les limites de débit et les conditions d'arrêt afin que les tests agressifs ne surchargent jamais les services en aval.
Comparez la latence p50/p90/p99, le débit et les budgets d'erreur dans différents environnements avec des rapports exportables.
Déclenchez des suites à partir de CI/CD, de planifications cron ou de webhooks, et diffusez des événements structurés vers des outils de surveillance.
Conçu spécifiquement pour les équipes interfonctionnelles responsables de la fiabilité des API.
Validez de nouveaux points de terminaison, surveillez les SLO et reproduisez les incidents de production avec des suites de relecture contrôlées.
Exécutez des packs de régression avec des assertions, l'extraction de données et des rapports riches prêts pour les parties prenantes.
Planifiez des vérifications de santé, connectez des alertes aux outils d'astreinte et maintenez les tableaux de bord en direct alignés sur les SLI.
Exécutez des vérifications basées sur des politiques pour TLS, la limitation de débit, le masquage des données sensibles et les contrôles réglementaires.
Lancez des tests de charge réalistes avant le lancement sans mettre en place d'infrastructure sur mesure.
Les modèles tirés du document de conception couvrent les tâches de fiabilité les plus courantes.
Pinger les points de terminaison critiques toutes les quelques heures et alerter lorsque le taux de succès ou la latence dépasse votre SLO.
Augmentez des milliers d'utilisateurs virtuels, mélangez des scénarios pondérés et étudiez la latence p99 avant le déploiement.
Enchaînez des flux multi-étapes tels que l'intégration ou le paiement, avec des assertions de réponse à chaque point de contact.
Codifiez les politiques PCI, SOX ou internes avec des vérifications à l'échelle de la suite pour l'application TLS, le masquage et les limites de débit.
Planifiez des sondes légères toutes les six heures et alertez le canal d'astreinte si les SLO sont enfreints.
const healthCheckSuite = {
name: 'API Health Check',
tests: [
{ name: 'User API', url: '{{BASE_URL}}/api/users', method: 'GET' },
{ name: 'Auth API', url: '{{BASE_URL}}/api/auth/verify', method: 'POST' },
{ name: 'Orders API', url: '{{BASE_URL}}/api/orders', method: 'GET' },
{ name: 'Products API', url: '{{BASE_URL}}/api/products', method: 'GET' }
],
schedule: '0 */6 * * *',
alertThreshold: { successRate: 95, maxResponseTime: 2000 }
};typescript
Modélisez le trafic de pointe, vérifiez que le service reste dans les objectifs de latence et capturez le comportement de nouvelle tentative.
const loadTestConfig = {
name: 'Login API Load Test',
target: {
url: '{{BASE_URL}}/api/auth/login',
method: 'POST',
body: { email: 'test@example.com', password: 'password123' }
},
load: { users: 100, duration: '5m', rampUp: '30s', iterations: 1000 },
assertions: [
{ type: 'status', value: 200 },
{ type: 'response_time', operator: '<', value: 500 },
{ type: 'success_rate', operator: '>', value: 99 }
]
};typescript
Faites glisser, regroupez et réutilisez les requêtes avec des garde-fous pour la stabilité et la visibilité.
Commencez à partir de modèles de santé, de régression ou personnalisés. Imbriquez des étapes, réutilisez des extraits et héritez des préréglages d'environnement.
Configurez la concurrence, la taille du lot, le délai, le délai d'attente, les politiques de nouvelle tentative et les conditions d'arrêt par suite.
Définissez des expressions cron, des fuseaux horaires et des règles de notification afin que les vérifications de fiabilité ne soient jamais oubliées.
Blocs d'architecture tirés directement des notes de conception technique.
Crée des pools de travailleurs, met les requêtes en lots, suit la progression et agrège les résultats au niveau de la suite.
Les sémaphores et la limitation de débit maintiennent les tests dans des limites sûres tout en mettant à jour les rappels de progression.
Diffuse des métriques en direct, dérive les taux de succès/erreur et déclenche des conditions d'alerte lorsque les seuils sont dépassés.
Calcule la latence des centiles, le débit, les taxonomies d'erreurs et partage des rapports de performance exportables.
Conserve l'historique des versions, gère les variables et gère les importations depuis API Tester, Postman ou Insomnia.
Les couches d'exécution, d'analyse et d'opérations restent découplées afin que le système puisse évoluer avec votre trafic.
Restez informé pendant l'exécution et partagez les aperçus par la suite.
Observez les p50/p90/p95/p99 évoluer seconde par seconde pour détecter les régressions précocement.
Regroupez les échecs par transport, délai d'attente ou erreur de serveur afin que les mesures d'atténuation soient évidentes.
Détaillez les nouvelles tentatives automatiques, les mécanismes de secours et quelle tentative a réussi.
Capturez des échantillons représentatifs de requêtes/réponses pour les post-mortems sans enregistrer chaque appel.
Les modèles UI/UX décrits dans le document de conception se reflètent dans l'expérience de production.
Suivez le flux de travail éprouvé de la documentation pour lancer votre première suite.
Allez plus vite en réutilisant le travail que vous avez déjà effectué.
Sélectionnez les requêtes enregistrées, conservez les variables et les secrets intacts, et convertissez-les instantanément en étapes de suite.
Téléchargez les collections et espaces de travail exportés. Le Testeur d'API en masse mappe les dossiers aux suites et préserve les tests.
Transformez les exécutions de tests en décisions grâce à des exportations structurées et des résumés.
Recevez un instantané des statistiques de latence, du débit et du taux de succès dans tous les environnements.
Partagez les résultats au format PDF, CSV, JSON ou charges utiles de webhook pour l'automatisation en aval.
Avertissez les équipes lorsque le taux de succès chute, que la latence augmente ou que les catégories d'erreurs dépassent les budgets.
Résultats rapportés dans le document de conception par les équipes utilisant le modèle de Testeur d'API en masse.
Planification de plus de 150 vérifications de service, réduction de la vérification manuelle de plusieurs heures à quelques minutes, et signalement des incidents en moins de cinq minutes.
Modélisation du trafic du jour du lancement avec des scénarios pondérés, résolution de trois goulots d'étranglement et atteinte de 580 RPS à p99 < 1s.
Codification des vérifications PCI DSS couvrant TLS, la limitation de débit et le masquage, réduisant les audits manuels et prouvant les contrôles à la demande.
Conçu pour s'intégrer aux pipelines de livraison modernes et aux piles d'observabilité.
Utilisez une planification de type cron pour exécuter des suites toutes les heures, toutes les nuits ou avant les fenêtres de trafic de pointe.
Invoquez des suites à partir de pipelines avec des jetons signés, des crochets git ou des scripts CLI et renvoyez les résultats dans l'état de la construction.
Poussez les baisses de taux de succès ou les pics de latence vers Slack, Teams, PagerDuty ou des webhooks personnalisés.
Centralisez les secrets et les remplacements par environnement tout en les synchronisant avec le Testeur d'API pour des analyses approfondies.
Clarification de la relation avec le Testeur d'API et le flux de travail en masse.
Utilisez le Testeur d'API pour déboguer une seule requête avec des inspecteurs riches. Le Testeur d'API en masse prend ces appels enregistrés, les exécute en parallèle et ajoute la planification, l'analyse et l'alerte.
Jusqu'à 100 travailleurs concurrents par suite avec des garde-fous pour la montée en charge, les conditions d'arrêt et les limites de débit afin que les systèmes en aval restent sûrs.
Oui. Téléchargez des collections ou des espaces de travail et le Testeur d'API en masse les convertit en suites, en préservant les requêtes, les tests et les variables d'environnement.
Absolument. Configurez des expressions cron, intégrez-vous à CI/CD ou déclenchez des suites via des webhooks pour maintenir les vérifications de santé API sans intervention manuelle.