Guide

Trigger.dev : des jobs en arrière-plan pour TypeScript

Trigger.dev exécute des jobs TypeScript longs avec relances, planifications et vue de chaque exécution. Tarifs, auto-hébergement et comparaison avec Temporal.

L'équipe CodeWorlds21 min de lecture ·

Pratique HTML et CSS dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article11

Trigger.dev est un service pour exécuter des jobs en arrière-plan écrits en TypeScript : des fonctions qui durent des minutes ou des heures, qui sont retentées après un échec et qui s'accompagnent d'une vue pas à pas de chaque exécution. La version actuelle est la 4.5.12 du 20 août 2026, le dépôt triggerdotdev/trigger.dev compte environ 16,1 mille étoiles, et il n'est pas archivé.

Ce que fait réellement Trigger.dev

Vous écrivez une fonction ordinaire dans un fichier du répertoire trigger, vous l'enveloppez dans task(), et ensuite vous l'appelez depuis votre application via trigger() au lieu d'un await. L'appel revient immédiatement avec un identifiant d'exécution, et le travail lui-même se déroule sur une machine côté Trigger.dev.

Cela règle d'un coup trois choses qu'une file faite maison traite séparément. La première est la durabilité : le job atterrit dans une file, survit au déploiement d'une nouvelle version de l'application et survit à un redémarrage de processus. La deuxième est la relance : quand la fonction lève une exception, la tentative est répétée avec un délai croissant selon des règles que vous fixez de façon déclarative. La troisième est l'observabilité : chaque exécution a sa propre trace dans le tableau de bord avec des journaux, la durée de chaque étape et la charge utile d'entrée complète, donc après un job en échec vous voyez exactement ce qui lui est parvenu.

Le périmètre est limité à l'écosystème Node. Le paquet @trigger.dev/sdk déclare engines.node à 18.20.0 ou plus et il n'existe pas de bibliothèques clientes pour Python ou Go. Si le travail d'arrière-plan de votre application est polyglotte, cette contrainte tranchera la question plus vite que n'importe quelle autre fonctionnalité.

Ce que Trigger.dev ne fait pas compte aussi. Ce n'est pas un broker de messages et il ne remplacera pas une file entre services. Ce n'est pas une base de données, donc l'état vit toujours dans Prisma ou dans Supabase. Il n'envoie pas de courrier, c'est le rôle de Resend, même si l'envoi depuis un job en arrière-plan est l'un des cas d'usage les plus courants.

Pourquoi une route d'API et un cron du fournisseur ne suffisent pas

Cette question revient toujours et mérite une réponse concrète, car les deux réponses sont parfois bonnes.

Le premier problème est la limite de temps d'exécution. Une fonction serverless a une borne supérieure de durée et est interrompue par la plateforme dès qu'elle la dépasse. Dans Vercel, vous la fixez en exportant maxDuration depuis un fichier de route dans l'app router ou via le champ functions de vercel.json, et une fonction qui dure plus longtemps que la limite déclarée est interrompue. Pour importer mille lignes depuis un fichier, générer un rapport ou enchaîner des appels à un modèle de langage, ce n'est pas une contrainte théorique mais ce contre quoi le premier déploiement se heurte. Trigger.dev inverse le montage : ici maxDuration est votre décision, la valeur minimale est de 5 secondes, et timeout.None supprime complètement le plafond. Plus important encore, maxDuration est comparé au temps CPU et non au temps réel, donc l'attente dans wait.for, triggerAndWait et batchTriggerAndWait ne compte pas du tout.

Le deuxième problème est la visibilité. Le cron d'un hébergeur appelle votre route HTTP et n'en sait que ce que dit le code de statut. Quand un job échoue au milieu d'une boucle sur deux cents enregistrements, les journaux contiennent un seul 500 et un message d'exception sans contexte. Vous ne savez pas quel enregistrement, avec quelle charge utile, combien de fois il avait déjà essayé, ni si l'exécution précédente s'est même terminée. Déboguer un job en arrière-plan sans vue de l'exécution, c'est deviner plutôt que diagnostiquer, et ce coût, plus souvent que la limite de temps, convainc une équipe d'adopter un service séparé.

Le troisième est la relance et la simultanéité. Répéter un appel HTTP en échec exige votre propre table de tentatives, et limiter le nombre de jobs parallèles qui martèlent une API tierce exige votre propre sémaphore. On peut écrire les deux. La question est de savoir si vous voulez les maintenir.

Quand une route d'API et un cron suffisent : le job se termine en quelques secondes, s'exécute rarement, et une exécution en échec n'appelle aucune analyse après coup. Envoyer un e-mail après une inscription ou nettoyer une table chaque nuit correspondent à cette description et n'ont pas besoin d'un service de plus.

Version, licence et état du projet

La version 4.5.12 est sortie le 20 août 2026, la précédente, 4.5.11, une semaine plus tôt. Le dernier changement sur la branche principale date du 21 août 2026, le dépôt compte 1414 forks et 423 issues ouvertes. Les versions arrivent tous les quelques jours, et des tags séparés helm-vX.Y.Z couvrent les charts pour les déploiements Kubernetes.

La licence comporte une divergence à connaître lors d'un audit de dépendances. Le fichier LICENSE à la racine du dépôt contient le texte complet de l'Apache License 2.0 et l'API GitHub indique Apache-2.0 pour ce dépôt. Le champ license du registre npm pour les paquets trigger.dev et @trigger.dev/sdk en version 4.5.12 indique en revanche MIT, et surtout, le fichier de licence à l'intérieur de l'archive publiée porte lui aussi le texte MIT. Autrement dit, ce que vous installez réellement est sous MIT, même si le dépôt déclare Apache. Les deux licences sont permissives et aucune n'introduit de clause source-available ni de restriction commerciale, donc il n'y a aucun risque pratique ici. La conséquence est différente : un outil qui collecte des métadonnées depuis GitHub et un outil qui lit package.json vous donneront deux réponses différentes à la même question. Si vous tenez un registre de licences dans votre entreprise, consignez les deux et notez d'où vient chacune.

Il y a toutefois une coupure de version stricte qui peut faire mal lors d'une mise à niveau. La version 4.5.0 est la dernière officiellement prise en charge pour les jobs écrits avec la version 3 du SDK. À partir de la 4.5.1, le serveur rejette les déclenchements, les déclenchements par lots et les déploiements de la v3, en renvoyant un message de migration. Si vous avez du vieux code en production, mettre à niveau une instance n'est pas un changement cosmétique mais une migration forcée.

Installation et première tâche

Intégrer l'outil à un projet existant se ramène à quatre commandes.

Bash
# project setup, creates trigger.config.ts and the trigger directory
npx trigger.dev@latest init

# local working mode, attaches to the DEV environment
npx trigger.dev@latest dev

# deploy tasks to the production environment
npx trigger.dev@latest deploy

# list of available commands with descriptions
npx trigger.dev@latest --help

La commande init crée un fichier de configuration à la racine du projet. Il ressemble à ceci.

TypeScript
import { defineConfig } from '@trigger.dev/sdk'

export default defineConfig({
  project: 'proj_gtcwttqhhtlasxgfuhxs',
  dirs: ['./trigger'],
  maxDuration: 300,
  machine: 'small-2x',
  retries: {
    enabledInDev: false,
    default: {
      maxAttempts: 3,
      minTimeoutInMs: 1000,
      maxTimeoutInMs: 10000,
      factor: 2,
      randomize: true
    }
  }
})

Le champ dirs pointe vers les répertoires qui contiennent vos tâches. Sans lui, Trigger.dev cherche de lui-même des répertoires nommés trigger, mais la documentation recommande de lister les chemins explicitement. Les fichiers dont le nom contient .test ou .spec sont ignorés automatiquement, et les motifs d'exclusion personnalisés vont dans ignorePatterns. Régler retries.enabledInDev sur false est la valeur que suppose init et c'est sensé : pendant le débogage local, trois répétitions de la même exception ne font qu'obscurcir le tableau.

La tâche elle-même est un fichier dans le répertoire trigger.

TypeScript
import { task, logger } from '@trigger.dev/sdk'

export const generateReport = task({
  id: 'generate-report',
  machine: 'medium-1x',
  maxDuration: 1800,
  retry: {
    maxAttempts: 5,
    factor: 1.8,
    minTimeoutInMs: 500,
    maxTimeoutInMs: 30_000,
    randomize: true
  },
  run: async (payload: { organizationId: string; month: string }) => {
    logger.info('report started', { organizationId: payload.organizationId })

    const rows = await loadInvoices(payload.organizationId, payload.month)
    const url = await renderPdf(rows)

    return { url, rowCount: rows.length }
  }
})

Le champ id doit être unique dans le projet et c'est l'identifiant que le serveur utilise, pas le nom de la variable. Le changer après le déploiement vous coupe de l'historique des exécutions, donc traitez-le comme une clé de base de données. La valeur renvoyée par run apparaît dans le tableau de bord et peut être lue par l'appelant, mais ce n'est pas un canal pour de grosses charges utiles, car la taille de la sortie est plafonnée.

L'appeler depuis l'application, par exemple depuis une route d'API dans Next.js, ressemble à ceci.

TypeScript
import { tasks } from '@trigger.dev/sdk'
import type { generateReport } from '@/trigger/generate-report'

const handle = await tasks.trigger<typeof generateReport>(
  'generate-report',
  { organizationId, month: '2026-08' },
  { idempotencyKey: `report-${organizationId}-2026-08`, tags: [organizationId] }
)

return Response.json({ runId: handle.id })

L'import réservé aux types est ici délibéré. Il donne au compilateur la possibilité de vérifier la charge utile tout en gardant le code de la tâche hors du bundle de l'application.

Relances, files et attente

Les règles de relance se fixent à deux endroits : les valeurs par défaut dans le fichier de configuration, les spécificités sur la tâche, ces dernières l'emportant sur les premières. Les champs sont maxAttempts, factor, minTimeoutInMs, maxTimeoutInMs et randomize. Le dernier ajoute une gigue aléatoire aux délais, ce qui compte quand mille jobs échouent en même temps parce qu'une API tierce est tombée et que tous reviendraient sinon dans la même seconde.

La relance agit sur toute la tâche, donc une étape terminée avant l'erreur s'exécute une seconde fois. C'est la conséquence la plus importante à garder en tête à la conception : soit les étapes sont idempotentes, soit vous découpez le travail en tâches plus petites reliées via triggerAndWait, où chacune a ses propres règles de relance et son propre historique dans le tableau de bord.

La simultanéité se pilote via des files. Par défaut, chaque tâche a sa propre file sans plafond, et la seule limite est le plafond de l'environnement. Un environnement a une limite de base et une limite extensible, par défaut deux fois plus haute, tandis qu'une seule file ne dépasse jamais la limite de base. Seules les exécutions actives comptent pour une file ; les exécutions différées et celles qui attendent leur tour ne prennent aucune place.

TypeScript
import { task, queue, wait } from '@trigger.dev/sdk'

export const externalApiQueue = queue({
  name: 'external-api',
  concurrencyLimit: 3
})

export const syncContact = task({
  id: 'sync-contact',
  queue: externalApiQueue,
  run: async (payload: { contactId: string }) => {
    await pushToCrm(payload.contactId)

    await wait.for({ minutes: 15 })

    const status = await readCrmStatus(payload.contactId)
    return { status }
  }
})

export const cleanupTask = task({
  id: 'cleanup',
  queue: { concurrencyLimit: 1 },
  run: async () => {
    await vacuumOldRows()
  }
})

Une file nommée permet à plusieurs tâches de partager une seule limite, ce qui est le bon outil quand trois tâches différentes tapent la même API externe plafonnée à trois connexions. La forme abrégée queue: { concurrencyLimit: 1 } placée directement sur une tâche ne contraint que cette tâche.

L'attente existe sous quatre formes : wait.for() pour une durée, wait.until() pour une date précise, wait.forToken() jusqu'à ce qu'un token soit complété par un événement externe, et inputStream.wait() pour des données sur un flux d'entrée. Dans Trigger.dev Cloud, une attente de plus de 5 secondes arrête la machine et ce temps n'est pas facturé comme usage de calcul. Il y a ici un détail facile à rater : du calcul gratuit n'est pas la même chose qu'une simultanéité libérée. La place de simultanéité ne revient qu'une fois la machine capturée en instantané, ce qui pour wait.for et wait.until arrive 60 secondes après le début de l'attente. Une attente plus courte occupe la place pendant toute sa durée.

Planifications et vue des exécutions

Une tâche récurrente se déclare via schedules.task(), mais la déclarer ne démarre rien. La planification doit être attachée séparément, dans le tableau de bord ou depuis le code.

TypeScript
import { schedules, logger } from '@trigger.dev/sdk'

export const dailyDigest = schedules.task({
  id: 'daily-digest',
  run: async (payload) => {
    logger.info('schedule fired', {
      scheduleId: payload.scheduleId,
      externalId: payload.externalId,
      timezone: payload.timezone,
      lastTimestamp: payload.lastTimestamp,
      upcoming: payload.upcoming
    })

    const since = payload.lastTimestamp ?? new Date(Date.now() - 86_400_000)
    await sendDigestSince(since)
  }
})

await schedules.create({
  task: dailyDigest.id,
  cron: '0 7 * * *',
  timezone: 'Europe/Warsaw',
  externalId: organizationId,
  deduplicationKey: `digest-${organizationId}`
})

La charge utile d'une tâche planifiée porte six champs : timestamp avec le moment d'exécution prévu, lastTimestamp avec l'exécution précédente ou undefined à la première, timezone au format IANA avec UTC par défaut, scheduleId, un externalId facultatif, et upcoming avec les cinq prochaines occurrences. En pratique, lastTimestamp est le plus utile d'entre eux, car il permet de traiter exactement la période écoulée depuis la dernière exécution réussie au lieu de supposer que le job s'est déclenché à l'heure.

Pour les planifications créées depuis le code, deduplicationKey est obligatoire en pratique même si le type dit le contraire. Sans lui, la même planification est ajoutée de nouveau à chaque appel, la tâche se met à se déclencher plusieurs fois, la facture grossit et vous atteignez la limite de planifications de votre forfait.

La vue des exécutions est la partie que vous ne pouvez pas reproduire avec des journaux de terminal. Le tableau de bord montre l'arbre des tâches avec le temps de chaque étape, la charge utile d'entrée, la sortie et chaque tentative, et une exécution en échec peut être rejouée en un clic sur la même charge utile. S'y ajoutent des alertes et un mécanisme temps réel qui expose l'état des exécutions au navigateur via le paquet @trigger.dev/react-hooks.

TypeScript
'use client'

import { useRealtimeRun } from '@trigger.dev/react-hooks'

export function ReportProgress({
  runId,
  publicAccessToken
}: {
  runId: string
  publicAccessToken: string
}) {
  const { run, error } = useRealtimeRun(runId, { accessToken: publicAccessToken })

  if (error) return <p>Could not read the run state.</p>

  return (
    <div>
      <p>Status: {run?.status}</p>
      {run?.output ? <a href={run.output.url}>Download the report</a> : null}
    </div>
  )
}

Le hook exige un token d'accès public, généré côté serveur et passé au composant. Avec une instance auto-hébergée, il existe aussi une option baseURL qui pointe vers votre propre adresse.

Tarifs cloud et limites des forfaits

La facturation a deux composantes : des frais de forfait fixes plus l'usage de calcul au-delà de l'allocation incluse. L'usage dépend de la machine choisie et du temps CPU réel, et les exécutions de l'environnement DEV ne sont pas facturées du tout.

ForfaitFraisUsage inclusSimultanéité en productionPlanificationsRétention des journaux
Free0 USD5 USD20101 jour
Hobby10 USD par mois10 USD501007 jours
Pro50 USD par mois50 USD200, extensible1000, extensible30 jours
Enterprisesur devis50 USD200, extensible1000, extensible30 jours

Trois éléments de ce tableau appellent un commentaire. Le forfait gratuit exige un compte GitHub vérifié et, une fois les 5 USD de crédit épuisés, les tâches cessent de s'exécuter jusqu'au passage à un forfait payant. Une rétention des journaux d'un jour sur le forfait gratuit vide en grande partie l'argument de l'observabilité, car un job qui a échoué pendant le week-end ne laisse aucune trace le lundi. Le forfait gratuit n'a pas non plus d'environnement de staging ni de branches de prévisualisation, ce qui compte pour le travail en équipe.

À cela s'ajoutent des limites techniques communes à tout le cloud. L'API accepte 1500 requêtes par minute, et chaque appel du SDK compte pour une requête, donc appeler trigger() dans une boucle sur mille enregistrements est la façon la plus courante de heurter ce plafond. La bonne réponse est batchTrigger(), qui contient jusqu'à 1000 tâches en un seul appel avec le SDK 4.3.1 et plus récent, et 500 avec les versions antérieures. Une file contient de 10 mille exécutions sur le forfait gratuit jusqu'à un million sur Pro, comptées par file et non sur l'ensemble de l'environnement. Toutes les exécutions cloud portent une durée de vie maximale imposée de 14 jours, après quoi les entrées en file disparaissent.

Une incohérence dans les documents du fournisseur lui-même mérite d'être dite clairement : la page des tarifs liste des valeurs de simultanéité différentes de celles de la page de documentation sur les limites, qui indique 10 exécutions pour le forfait gratuit, 25 pour Hobby et plus de 100 pour Pro. Avant de dimensionner le débit, consultez la page Limits dans votre propre tableau de bord, car elle montre les valeurs en vigueur pour votre organisation.

MachinevCPUMémoireDisque
micro0.250.25 Go10 Go
small-1x (par défaut)0.50.5 Go10 Go
medium-1x12 Go10 Go
large-2x816 Go10 Go

La machine pilote directement le coût, donc relever le préréglage sans raison est le chemin le plus simple vers une facture inutilement élevée. À l'inverse, trop peu de mémoire se termine par une erreur TASK_PROCESS_OOM_KILLED, que Trigger.dev détecte aussi quand un processus enfant comme ffmpeg dépasse la limite.

Auto-hébergement et ce qu'il laisse de côté

Les sources permettent d'exécuter l'ensemble sur votre propre infrastructure via Docker Compose ou Kubernetes. L'architecture se divise en deux parties à mise à l'échelle indépendante : l'application web avec le tableau de bord, Redis et Postgres, et la couche d'exécution avec le superviseur et les runners qui exécutent vos tâches.

La documentation dit que la version auto-hébergée est fonctionnellement la même que celle du cloud, et liste aussitôt les exceptions. Les démarrages à chaud manquent, ce qui signifie des démarrages plus lents pour les exécutions consécutives. La mise à l'échelle automatique manque, donc vous dimensionnez à la main le nombre de nœuds workers. Le support dédié manque, il reste le canal Discord. La lacune la plus grave, cependant, est l'absence de checkpoints, car ce sont eux qui rendent les attentes non bloquantes. Sans eux, une tâche qui attend une journée dans wait.for retient des ressources toute cette journée au lieu d'être capturée en instantané puis reprise. Si votre mode de travail repose sur de longues attentes, cette seule ligne tranche la question.

Les limites d'une instance auto-hébergée sont pour la plupart configurables via des variables d'environnement sur le conteneur de l'application web : simultanéité, limites de débit, tailles de files, tailles de charge utile et de sortie, taille de lot, taille des journaux, définitions de machines et réglages OpenTelemetry. Ce qui reste fixe : la longueur des paquets d'entrée et de sortie fixée à 128 Ko, ainsi que les plafonds sur les alertes, les planifications, les membres de l'équipe et les branches de prévisualisation, fixés à des valeurs que vous n'atteindrez pas en pratique. Les journaux ne sont jamais supprimés, ce qui est un avantage jusqu'à ce que vous partiez à la chasse à l'espace disque. Les préréglages de machines se remplacent avec un fichier JSON désigné par MACHINE_PRESETS_OVERRIDE_PATH, et la durée de vie maximale des exécutions par la variable RUN_ENGINE_DEFAULT_MAX_TTL.

Le fournisseur recommande de s'en tenir aux versions étiquetées et de garder la version du serveur alignée sur la version de l'outil en ligne de commande. C'est un conseil judicieux, et avec la coupure entre la 4.5.0 et la 4.5.1 il est carrément nécessaire.

Trigger.dev face aux alternatives

OutilCe que vous obtenezContrainte principaleÀ choisir quand
Trigger.devTâches TypeScript, relances, planifications, un tableau de bord des exécutionsNode uniquement, pas de checkpoints en auto-hébergementUne application TypeScript avec de longs jobs en arrière-plan
TemporalWorkflows durables avec rejeu garanti de l'état, nombreux langagesBarrière d'entrée plus haute, un cluster séparé à maintenirProcessus critiques, plusieurs langages, longues sagas
BullMQ avec RedisUne bibliothèque de files dans votre propre processus, contrôle totalTableau de bord, relances et mise à l'échelle à construire par vousVous exploitez déjà Redis et il vous faut une file simple interne au service
Cron de l'hébergeurUne route HTTP appelée à heure fixe, zéro configurationLimite de temps de la fonction, aucune vue de l'exécutionJobs récurrents courts sans besoin de diagnostic

Choisir entre Trigger.dev et Temporal se ramène à ce que vous voulez maintenir. Temporal offre des garanties plus fortes et prend en charge de nombreux langages, mais le cluster est le vôtre et la barrière d'entrée est réelle. Trigger.dev est plus étroit et plus confortable, tandis que la variante cloud vous lie à un seul fournisseur. Le code des tâches reste du TypeScript ordinaire, donc le réécrire pour une autre plateforme est faisable, mais les identifiants d'exécution, les planifications, les alertes et tout l'historique restent chez le service.

Erreurs courantes

La première, c'est d'appeler trigger() dans une boucle. Chaque appel est une requête d'API séparée et la limite est de 1500 par minute. Utilisez plutôt batchTrigger().

La deuxième, c'est de supposer qu'une tâche s'exécute exactement une fois. Une relance répète tout le run, donc une étape terminée avant l'erreur s'exécute de nouveau. Une clé d'idempotence sur le déclenchement protège contre un déclenchement dupliqué, mais pas contre une étape répétée à l'intérieur de la fonction.

La troisième, ce sont des planifications créées depuis le code sans deduplicationKey. Chaque déploiement ajoute alors une copie de plus de la même planification.

La quatrième, c'est de confondre temps réel et temps CPU en réglant maxDuration. La valeur se rapporte au temps CPU et les attentes en sont exclues, donc une tâche avec une limite de 60 secondes peut durer de nombreuses heures au calendrier.

La cinquième, c'est une machine choisie trop petite par accident. Le préréglage par défaut small-1x a 0,5 Go de mémoire, ce qui, en chargeant un gros fichier en mémoire, se termine par une erreur de manque de mémoire plutôt que par une exception lisible.

La sixième, c'est de faire passer des charges utiles par le champ de sortie d'une tâche. Les tailles de sortie et de paquets sont plafonnées, et en auto-hébergement le paquet a un seuil strict de 128 Ko. Écrivez les gros résultats dans un stockage objet et renvoyez l'adresse.

La septième, c'est de mettre à niveau une instance auto-hébergée au-delà de la version 4.5.0 avec des tâches du SDK version 3 non migrées. Le serveur rejettera les déclenchements et les déploiements au lieu de continuer.

FAQ

Ai-je besoin de Trigger.dev alors que j'ai déjà le cron de mon hébergeur ?

Si le job se termine en quelques secondes et que son échec n'appelle aucune analyse après coup, non. Un service séparé commence à être rentable quand le travail dépasse la limite de temps des fonctions serverless, quand il vous faut des relances avec délai croissant, ou quand, après une exécution en échec, vous voulez voir la charge utile d'entrée et l'historique des tentatives plutôt qu'un simple code de statut HTTP.

La version auto-hébergée a-t-elle toutes les fonctionnalités ?

Non. Le code est le même, mais les démarrages à chaud, la mise à l'échelle automatique, le support dédié et les checkpoints manquent. Ce dernier point compte, car sans checkpoints les longues attentes bloquent des ressources pendant toute leur durée au lieu de mettre la machine en veille.

Combien coûte l'exécution d'une tâche ?

Vous payez des frais de forfait fixes plus l'usage de calcul au-delà de l'allocation incluse, avec un tarif qui dépend du préréglage de machine et du temps CPU. Le forfait gratuit accorde 5 USD de crédit et exige un compte GitHub vérifié, Hobby coûte 10 USD par mois avec 10 USD d'usage inclus, Pro 50 USD par mois avec 50 USD d'usage inclus. Les exécutions de l'environnement DEV ne sont pas facturées.

Une tâche peut-elle durer aussi longtemps qu'on veut ?

En pratique oui, car vous fixez vous-même le plafond via maxDuration, et timeout.None le supprime entièrement. La valeur minimale est de 5 secondes. La limite se rapporte au temps CPU, donc les attentes dans wait.for, triggerAndWait et batchTriggerAndWait ne comptent pas.

Puis-je utiliser Trigger.dev avec un autre langage que TypeScript ?

Pas directement. Les paquets clients n'existent que pour Node, et @trigger.dev/sdk exige la version 18.20.0 ou plus. Les tâches peuvent être déclenchées via l'API HTTP depuis n'importe quel langage, mais le code des tâches lui-même reste en TypeScript ou JavaScript. Pour une pile polyglotte, Temporal a plus de sens.

Quelle est la licence et y a-t-il quelque chose de propriétaire ?

Le fichier LICENSE du dépôt contient l'Apache License 2.0, tandis que les paquets du registre npm déclarent MIT. Les deux licences sont permissives et ne contiennent aucune clause qui restreint l'usage commercial. Aucun répertoire de ce dépôt n'est sous une licence propriétaire distincte.

Les limites et versions actuelles sont décrites dans la documentation de Trigger.dev, les forfaits sont listés sur la page des tarifs, et le code source se trouve dans le dépôt GitHub.

Dernières actualités : Trigger.dev

Toutes les actualités

À lire aussi