Use cron jobs ↗

langchain guide intermediate workflows
no

Original Documentation

Documentation Index#

Fetch the complete documentation index at: https://docs.langchain.com/llms.txt Use this file to discover all available pages before exploring further.

There are many situations in which it is useful to run an assistant on a schedule.

For example, say that you’re building an assistant that runs daily and sends an email summary of the day’s news. You could use a cron job to run the assistant every day at 8:00 PM.

LangSmith Deployment supports cron jobs, which run on a user-defined schedule. The user specifies a schedule, an assistant, and some input. After that, on the specified schedule, the server will:

  • Create a new thread with the specified assistant
  • Send the specified input to that thread

Note that this sends the same input to the thread every time.

The LangSmith Deployment API provides several endpoints for creating and managing cron jobs. See the API reference for more details.

Sometimes you don’t want to run your graph based on user interaction, but rather you would like to schedule your graph to run on a schedule - for example if you wish for your graph to compose and send out a weekly email of to-dos for your team. LangSmith Deployment allows you to do this without having to write your own script by using the Crons client. To schedule a graph job, you need to pass a cron expression to inform the client when you want to run the graph. Cron jobs are run in the background and do not interfere with normal invocations of the graph.

All cron schedules are interpreted in UTC. Make sure to convert your desired execution time to UTC when specifying the schedule.

Setup#

First, let’s set up our SDK client, assistant, and thread:

    from langgraph_sdk import get_client

    client = get_client(url=<DEPLOYMENT_URL>)
    # Using the graph deployed with the name "agent"
    assistant_id = "agent"
    # create thread
    thread = await client.threads.create()
    print(thread)
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="Javascript"></span>
```js
    import { Client } from "@langchain/langgraph-sdk";

    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
    // Using the graph deployed with the name "agent"
    const assistantId = "agent";
    // create thread
    const thread = await client.threads.create();
    console.log(thread);
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="CURL"></span>
```bash
    curl --request POST \
        --url <DEPLOYMENT_URL>/assistants/search \
        --header 'Content-Type: application/json' \
        --data '{
            "limit": 10,
            "offset": 0
        }' | jq -c 'map(select(.config == null or .config == {})) | .[0].graph_id' && \
    curl --request POST \
        --url <DEPLOYMENT_URL>/threads \
        --header 'Content-Type: application/json' \
        --data '{}'
    ```
  <span class="tab-end"></span>
<span class="tab-group-end"></span>

Output:

{ ’thread_id’: ‘9dde5490-2b67-47c8-aa14-4bfec88af217’, ‘created_at’: ‘2024-08-30T23:07:38.242730+00:00’, ‘updated_at’: ‘2024-08-30T23:07:38.242730+00:00’, ‘metadata’: {}, ‘status’: ‘idle’, ‘config’: {}, ‘values’: None }


## Cron job on a thread

To create a cron job associated with a specific thread, you can write:

<span class="tab-group-start"></span>
  <span class="tab-start" data-tab-title="Python"></span>
```python
    # This schedules a job to run at 15:27 (3:27PM) UTC every day
    cron_job = await client.crons.create_for_thread(
        thread["thread_id"],
        assistant_id,
        schedule="27 15 * * *",
        input={"messages": [{"role": "user", "content": "What time is it?"}]},
    )
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="Javascript"></span>
```js
    // This schedules a job to run at 15:27 (3:27PM) UTC every day
    const cronJob = await client.crons.create_for_thread(
      thread["thread_id"],
      assistantId,
      {
        schedule: "27 15 * * *",
        input: { messages: [{ role: "user", content: "What time is it?" }] }
      }
    );
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="CURL"></span>
```bash
    curl --request POST \
        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/crons \
        --header 'Content-Type: application/json' \
        --data '{
            "assistant_id": <ASSISTANT_ID>,
        }'
    ```
  <span class="tab-end"></span>
<span class="tab-group-end"></span>

Note that it is **very** important to delete `Cron` jobs that are no longer useful. Otherwise you could rack up unwanted API charges to the LLM! You can delete a `Cron` job using the following code:

<span class="tab-group-start"></span>
  <span class="tab-start" data-tab-title="Python"></span>
```python
    await client.crons.delete(cron_job["cron_id"])
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="Javascript"></span>
```js
    await client.crons.delete(cronJob["cron_id"]);
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="CURL"></span>
```bash
    curl --request DELETE \
        --url <DEPLOYMENT_URL>/runs/crons/<CRON_ID>
    ```
  <span class="tab-end"></span>
<span class="tab-group-end"></span>

## Cron job stateless

You can also create stateless cron jobs by using the following code. Stateless cron jobs create a new thread for each execution:

<span class="tab-group-start"></span>
  <span class="tab-start" data-tab-title="Python"></span>
```python
    # This schedules a job to run at 15:27 (3:27PM) UTC every day
    cron_job_stateless = await client.crons.create(
        assistant_id,
        schedule="27 15 * * *",
        input={"messages": [{"role": "user", "content": "What time is it?"}]},
    )
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="Javascript"></span>
```js
    // This schedules a job to run at 15:27 (3:27PM) UTC every day
    const cronJobStateless = await client.crons.create(
      assistantId,
      {
        schedule: "27 15 * * *",
        input: { messages: [{ role: "user", content: "What time is it?" }] }
      }
    );
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="CURL"></span>
```bash
    curl --request POST \
        --url <DEPLOYMENT_URL>/runs/crons \
        --header 'Content-Type: application/json' \
        --data '{
            "assistant_id": <ASSISTANT_ID>,
        }'
    ```
  <span class="tab-end"></span>
<span class="tab-group-end"></span>

Again, remember to delete your job once you are done with it!

<span class="tab-group-start"></span>
  <span class="tab-start" data-tab-title="Python"></span>
```python
    await client.crons.delete(cron_job_stateless["cron_id"])
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="Javascript"></span>
```js
    await client.crons.delete(cronJobStateless["cron_id"]);
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="CURL"></span>
```bash
    curl --request DELETE \
        --url <DEPLOYMENT_URL>/runs/crons/<CRON_ID>
    ```
  <span class="tab-end"></span>
<span class="tab-group-end"></span>

## Thread cleanup for stateless crons

<span class="callout-start" data-callout-type="note"></span>
  This feature requires LangGraph API version **0.5.18** or later and Python SDK **0.3.2** or later, or JavaScript SDK **1.4.0** or later.
<span class="callout-end"></span>

Every time a stateless cron is triggered, a new thread is created. Control what happens to that thread after the run completes using the `on_run_completed` parameter:

* **`"delete"`** (default): Automatically deletes the thread after the run completes.
* **`"keep"`**: Preserves the thread for later retrieval. You are responsible for cleaning up these threads. See [how to add TTLs to your application](/langsmith/configure-ttl) for the recommended approach.

### Example: Keeping threads for later retrieval

<span class="tab-group-start"></span>
  <span class="tab-start" data-tab-title="Python"></span>
```python
    # Create a stateless cron that keeps threads after execution.
    # Configure checkpointer.ttl in langgraph.json to auto-delete old threads.
    # See: https://docs.langchain.com/langsmith/configure-ttl
    cron_job = await client.crons.create(
        assistant_id,
        schedule="27 15 * * *",
        input={"messages": [{"role": "user", "content": "Daily report"}]},
        on_run_completed="keep"
    )

    # You can later retrieve the runs and their results
    runs = await client.runs.search(
        metadata={"cron_id": cron_job["cron_id"]}
    )
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="Javascript"></span>
```js
    // Create a stateless cron that keeps threads after execution.
    // Configure checkpointer.ttl in langgraph.json to auto-delete old threads.
    // See: https://docs.langchain.com/langsmith/configure-ttl
    const cronJob = await client.crons.create(
      assistantId,
      {
        schedule: "27 15 * * *",
        input: { messages: [{ role: "user", content: "Daily report" }] },
        onRunCompleted: "keep"
      }
    );

    // You can later retrieve the runs and their results
    const runs = await client.runs.search({
      metadata: { cron_id: cronJob["cron_id"] }
    });
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="CURL"></span>
```bash
    # Create a stateless cron that keeps threads after execution.
    # Configure checkpointer.ttl in langgraph.json to auto-delete old threads.
    # See: https://docs.langchain.com/langsmith/configure-ttl
    curl --request POST \
        --url <DEPLOYMENT_URL>/runs/crons \
        --header 'Content-Type: application/json' \
        --data '{
            "assistant_id": "<ASSISTANT_ID>",
            "schedule": "27 15 * * *",
            "input": {"messages": [{"role": "user", "content": "Daily report"}]},
            "on_run_completed": "keep"
        }'
    ```
  <span class="tab-end"></span>
<span class="tab-group-end"></span>

***


  <span class="callout-start" data-callout-type="note"></span>
[Edit this page on GitHub](https://github.com/langchain-ai/docs/edit/main/src/langsmith/cron-jobs.mdx) or [file an issue](https://github.com/langchain-ai/docs/issues/new/choose).
  <span class="callout-end"></span>

  <span class="callout-start" data-callout-type="note"></span>
[Connect these docs](/use-these-docs) to Claude, VSCode, and more via MCP for real-time answers.
  <span class="callout-end"></span>
Link last verified June 7, 2026. View original ↗
Source: LangChain Docs
Link last verified: 2026-03-04