diff --git a/README.md b/README.md
index 89b0c5c34..322e83718 100644
--- a/README.md
+++ b/README.md
@@ -108,6 +108,12 @@ ngrok http 8080
 5. Copy the temporary access token there and set env var `WHATSAPP_ACCESS_TOKEN = XXXX`
 
 
+**(Optional) Use the test script to send yourself messages** 
+
+```bash
+python manage.py runscript test_wa_msg_send --script-args 104696745926402 +918764022384
+```
+Replace `+918764022384` with your number and `104696745926402` with the test number ID
 
 ## Dangerous postgres commands
 
@@ -145,6 +151,9 @@ pg_restore --no-privileges --no-owner -d $PGDATABASE $fname
 cid=$(docker ps  | grep gooey-api-prod | cut -d " " -f 1 | head -1)
 # exec the script to create the fixture
 docker exec -it $cid poetry run ./manage.py runscript create_fixture
+```
+
+```bash
 # copy the fixture outside container
 docker cp $cid:/app/fixture.json .
 # print the absolute path
@@ -178,3 +187,4 @@ rsync -P -a <username>@captain.us-1.gooey.ai:/home/<username>/fixture.json .
 createdb -T template0 $PGDATABASE
 pg_dump $SOURCE_DATABASE | psql -q $PGDATABASE
 ```
+
diff --git a/app_users/admin.py b/app_users/admin.py
index 191197eb6..ffe8ccdc6 100644
--- a/app_users/admin.py
+++ b/app_users/admin.py
@@ -41,6 +41,7 @@ class AppUserAdmin(admin.ModelAdmin):
         "view_transactions",
         "open_in_firebase",
         "open_in_stripe",
+        "low_balance_email_sent_at",
     ]
 
     @admin.display(description="User Runs")
diff --git a/app_users/migrations/0012_appuser_low_balance_email_sent_at.py b/app_users/migrations/0012_appuser_low_balance_email_sent_at.py
new file mode 100644
index 000000000..efc2beaf0
--- /dev/null
+++ b/app_users/migrations/0012_appuser_low_balance_email_sent_at.py
@@ -0,0 +1,18 @@
+# Generated by Django 4.2.7 on 2024-02-14 07:23
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('app_users', '0011_appusertransaction_charged_amount_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='appuser',
+            name='low_balance_email_sent_at',
+            field=models.DateTimeField(blank=True, null=True),
+        ),
+    ]
diff --git a/app_users/migrations/0013_appusertransaction_app_users_a_user_id_9b2e8d_idx_and_more.py b/app_users/migrations/0013_appusertransaction_app_users_a_user_id_9b2e8d_idx_and_more.py
new file mode 100644
index 000000000..b992887bb
--- /dev/null
+++ b/app_users/migrations/0013_appusertransaction_app_users_a_user_id_9b2e8d_idx_and_more.py
@@ -0,0 +1,21 @@
+# Generated by Django 4.2.7 on 2024-02-28 14:16
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('app_users', '0012_appuser_low_balance_email_sent_at'),
+    ]
+
+    operations = [
+        migrations.AddIndex(
+            model_name='appusertransaction',
+            index=models.Index(fields=['user', 'amount', '-created_at'], name='app_users_a_user_id_9b2e8d_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='appusertransaction',
+            index=models.Index(fields=['-created_at'], name='app_users_a_created_3c27fe_idx'),
+        ),
+    ]
diff --git a/app_users/models.py b/app_users/models.py
index 576ea0390..9299fba47 100644
--- a/app_users/models.py
+++ b/app_users/models.py
@@ -89,6 +89,8 @@ class AppUser(models.Model):
     stripe_customer_id = models.CharField(max_length=255, default="", blank=True)
     is_paying = models.BooleanField("paid", default=False)
 
+    low_balance_email_sent_at = models.DateTimeField(null=True, blank=True)
+
     created_at = models.DateTimeField(
         "created", editable=False, blank=True, default=timezone.now
     )
@@ -207,7 +209,11 @@ def search_stripe_customer(self) -> stripe.Customer | None:
         if not self.uid:
             return None
         if self.stripe_customer_id:
-            return stripe.Customer.retrieve(self.stripe_customer_id)
+            try:
+                return stripe.Customer.retrieve(self.stripe_customer_id)
+            except stripe.error.InvalidRequestError as e:
+                if e.http_status != 404:
+                    raise
         try:
             customer = stripe.Customer.search(
                 query=f'metadata["uid"]:"{self.uid}"'
@@ -263,6 +269,10 @@ class AppUserTransaction(models.Model):
 
     class Meta:
         verbose_name = "Transaction"
+        indexes = [
+            models.Index(fields=["user", "amount", "-created_at"]),
+            models.Index(fields=["-created_at"]),
+        ]
 
     def __str__(self):
         return f"{self.invoice_id} ({self.amount})"
diff --git a/bots/admin.py b/bots/admin.py
index 49321ba35..23d0a9dd5 100644
--- a/bots/admin.py
+++ b/bots/admin.py
@@ -5,7 +5,7 @@
 from django import forms
 from django.conf import settings
 from django.contrib import admin
-from django.db.models import Max, Count, F
+from django.db.models import Max, Count, F, Sum
 from django.template import loader
 from django.utils import dateformat
 from django.utils.safestring import mark_safe
@@ -28,8 +28,6 @@
     WorkflowMetadata,
 )
 from bots.tasks import create_personal_channels_for_all_members
-from daras_ai.image_input import truncate_text_words
-from daras_ai_v2.base import BasePage
 from gooeysite.custom_actions import export_to_excel, export_to_csv
 from gooeysite.custom_filters import (
     related_json_field_summary,
@@ -168,6 +166,7 @@ class BotIntegrationAdmin(admin.ModelAdmin):
             "Settings",
             {
                 "fields": [
+                    "streaming_enabled",
                     "show_feedback_buttons",
                     "analysis_run",
                     "view_analysis_results",
@@ -265,10 +264,14 @@ class SavedRunAdmin(admin.ModelAdmin):
         "view_parent_published_run",
         "run_time",
         "price",
+        "is_api_call",
         "created_at",
         "updated_at",
     ]
-    list_filter = ["workflow"]
+    list_filter = [
+        "workflow",
+        "is_api_call",
+    ]
     search_fields = ["workflow", "example_id", "run_id", "uid"]
     autocomplete_fields = ["parent_version"]
 
@@ -277,10 +280,12 @@ class SavedRunAdmin(admin.ModelAdmin):
         "parent",
         "view_bots",
         "price",
+        "view_usage_cost",
         "transaction",
         "created_at",
         "updated_at",
         "run_time",
+        "is_api_call",
     ]
 
     actions = [export_to_csv, export_to_excel]
@@ -289,16 +294,25 @@ class SavedRunAdmin(admin.ModelAdmin):
         django.db.models.JSONField: {"widget": JSONEditorWidget},
     }
 
+    def get_queryset(self, request):
+        return (
+            super()
+            .get_queryset(request)
+            .prefetch_related(
+                "parent_version",
+                "parent_version__published_run",
+                "parent_version__published_run__saved_run",
+            )
+        )
+
     def lookup_allowed(self, key, value):
         if key in ["parent_version__published_run__id__exact"]:
             return True
         return super().lookup_allowed(key, value)
 
     def view_user(self, saved_run: SavedRun):
-        return change_obj_url(
-            AppUser.objects.get(uid=saved_run.uid),
-            label=f"{saved_run.uid}",
-        )
+        user = AppUser.objects.get(uid=saved_run.uid)
+        return change_obj_url(user)
 
     view_user.short_description = "View User"
 
@@ -312,6 +326,15 @@ def view_parent_published_run(self, saved_run: SavedRun):
         pr = saved_run.parent_published_run()
         return pr and change_obj_url(pr)
 
+    @admin.display(description="Usage Costs")
+    def view_usage_cost(self, saved_run: SavedRun):
+        total_cost = saved_run.usage_costs.aggregate(total_cost=Sum("dollar_amount"))[
+            "total_cost"
+        ]
+        return list_related_html_url(
+            saved_run.usage_costs, extra_label=f"${total_cost.normalize()}"
+        )
+
 
 @admin.register(PublishedRunVersion)
 class PublishedRunVersionAdmin(admin.ModelAdmin):
@@ -491,6 +514,7 @@ class MessageAdmin(admin.ModelAdmin):
         "prev_msg_content",
         "prev_msg_display_content",
         "prev_msg_saved_run",
+        "response_time",
     ]
     ordering = ["created_at"]
     actions = [export_to_csv, export_to_excel]
@@ -550,6 +574,7 @@ def get_fieldsets(self, request, msg: Message = None):
                 "Analysis",
                 {
                     "fields": [
+                        "response_time",
                         "analysis_result",
                         "analysis_run",
                         "question_answered",
diff --git a/bots/admin_links.py b/bots/admin_links.py
index 94086e348..c06601953 100644
--- a/bots/admin_links.py
+++ b/bots/admin_links.py
@@ -35,6 +35,7 @@ def list_related_html_url(
     query_param: str = None,
     instance_id: int = None,
     show_add: bool = True,
+    extra_label: str = None,
 ) -> typing.Optional[str]:
     num = manager.all().count()
 
@@ -60,6 +61,8 @@ def list_related_html_url(
     ).url
 
     label = f"{num} {meta.verbose_name if num == 1 else meta.verbose_name_plural}"
+    if extra_label:
+        label = f"{label} ({extra_label})"
 
     if show_add:
         add_related_url = furl(
diff --git a/bots/migrations/0056_botintegration_streaming_enabled.py b/bots/migrations/0056_botintegration_streaming_enabled.py
new file mode 100644
index 000000000..dcf1366fa
--- /dev/null
+++ b/bots/migrations/0056_botintegration_streaming_enabled.py
@@ -0,0 +1,20 @@
+# Generated by Django 4.2.7 on 2024-01-31 19:14
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("bots", "0055_workflowmetadata"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="botintegration",
+            name="streaming_enabled",
+            field=models.BooleanField(
+                default=False,
+                help_text="If set, the bot will stream messages to the frontend",
+            ),
+        ),
+    ]
diff --git a/bots/migrations/0057_message_response_time_and_more.py b/bots/migrations/0057_message_response_time_and_more.py
new file mode 100644
index 000000000..5bdecd39c
--- /dev/null
+++ b/bots/migrations/0057_message_response_time_and_more.py
@@ -0,0 +1,23 @@
+# Generated by Django 4.2.7 on 2024-02-05 15:11
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bots', '0056_botintegration_streaming_enabled'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='message',
+            name='response_time',
+            field=models.DurationField(default=None, help_text='The time it took for the bot to respond to the corresponding user message', null=True),
+        ),
+        migrations.AlterField(
+            model_name='botintegration',
+            name='streaming_enabled',
+            field=models.BooleanField(default=False, help_text='If set, the bot will stream messages to the frontend (Slack only)'),
+        ),
+    ]
diff --git a/bots/migrations/0058_alter_savedrun_unique_together_and_more.py b/bots/migrations/0058_alter_savedrun_unique_together_and_more.py
new file mode 100644
index 000000000..a4e137127
--- /dev/null
+++ b/bots/migrations/0058_alter_savedrun_unique_together_and_more.py
@@ -0,0 +1,21 @@
+# Generated by Django 4.2.7 on 2024-02-06 18:24
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bots', '0057_message_response_time_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterUniqueTogether(
+            name='savedrun',
+            unique_together={('run_id', 'uid'), ('workflow', 'example_id')},
+        ),
+        migrations.AddIndex(
+            model_name='savedrun',
+            index=models.Index(fields=['run_id', 'uid'], name='bots_savedr_run_id_7b0b34_idx'),
+        ),
+    ]
diff --git a/bots/migrations/0059_savedrun_is_api_call.py b/bots/migrations/0059_savedrun_is_api_call.py
new file mode 100644
index 000000000..dc93057fc
--- /dev/null
+++ b/bots/migrations/0059_savedrun_is_api_call.py
@@ -0,0 +1,18 @@
+# Generated by Django 4.2.7 on 2024-02-12 07:54
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bots', '0058_alter_savedrun_unique_together_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='savedrun',
+            name='is_api_call',
+            field=models.BooleanField(default=False),
+        ),
+    ]
diff --git a/bots/migrations/0060_conversation_reset_at.py b/bots/migrations/0060_conversation_reset_at.py
new file mode 100644
index 000000000..10cd847b6
--- /dev/null
+++ b/bots/migrations/0060_conversation_reset_at.py
@@ -0,0 +1,18 @@
+# Generated by Django 4.2.7 on 2024-02-20 16:49
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bots', '0059_savedrun_is_api_call'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='conversation',
+            name='reset_at',
+            field=models.DateTimeField(blank=True, default=None, null=True),
+        ),
+    ]
diff --git a/bots/models.py b/bots/models.py
index fd6071f58..534ccdd7a 100644
--- a/bots/models.py
+++ b/bots/models.py
@@ -254,13 +254,15 @@ class SavedRun(models.Model):
     page_title = models.TextField(default="", blank=True, help_text="(Deprecated)")
     page_notes = models.TextField(default="", blank=True, help_text="(Deprecated)")
 
+    is_api_call = models.BooleanField(default=False)
+
     objects = SavedRunQuerySet.as_manager()
 
     class Meta:
         ordering = ["-updated_at"]
         unique_together = [
             ["workflow", "example_id"],
-            ["workflow", "run_id", "uid"],
+            ["run_id", "uid"],
         ]
         constraints = [
             models.CheckConstraint(
@@ -273,6 +275,7 @@ class Meta:
             models.Index(fields=["-created_at"]),
             models.Index(fields=["-updated_at"]),
             models.Index(fields=["workflow"]),
+            models.Index(fields=["run_id", "uid"]),
             models.Index(fields=["workflow", "run_id", "uid"]),
             models.Index(fields=["workflow", "example_id", "run_id", "uid"]),
             models.Index(fields=["workflow", "example_id", "hidden"]),
@@ -571,6 +574,11 @@ class BotIntegration(models.Model):
         help_text="If provided, the message content will be analyzed for this bot using this saved run",
     )
 
+    streaming_enabled = models.BooleanField(
+        default=False,
+        help_text="If set, the bot will stream messages to the frontend (Slack only)",
+    )
+
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
 
@@ -694,8 +702,8 @@ def to_df_format(
                     .replace(tzinfo=None)
                 )
                 row |= {
-                    "Last Sent": last_time.strftime("%b %d, %Y %I:%M %p"),
-                    "First Sent": first_time.strftime("%b %d, %Y %I:%M %p"),
+                    "Last Sent": last_time.strftime(settings.SHORT_DATETIME_FORMAT),
+                    "First Sent": first_time.strftime(settings.SHORT_DATETIME_FORMAT),
                     "A7": not convo.d7(),
                     "A30": not convo.d30(),
                     "R1": last_time - first_time < datetime.timedelta(days=1),
@@ -712,7 +720,26 @@ def to_df_format(
                 "Bot": str(convo.bot_integration),
             }
             rows.append(row)
-        df = pd.DataFrame.from_records(rows)
+        df = pd.DataFrame.from_records(
+            rows,
+            columns=[
+                "Name",
+                "Messages",
+                "Correct Answers",
+                "Thumbs up",
+                "Thumbs down",
+                "Last Sent",
+                "First Sent",
+                "A7",
+                "A30",
+                "R1",
+                "R7",
+                "R30",
+                "Delta Hours",
+                "Created At",
+                "Bot",
+            ],
+        )
         return df
 
 
@@ -799,6 +826,7 @@ class Conversation(models.Model):
     )
 
     created_at = models.DateTimeField(auto_now_add=True)
+    reset_at = models.DateTimeField(null=True, blank=True, default=None)
 
     objects = ConversationQuerySet.as_manager()
 
@@ -901,14 +929,30 @@ def to_df_format(
                 "Message (EN)": message.content,
                 "Sent": message.created_at.astimezone(tz)
                 .replace(tzinfo=None)
-                .strftime("%b %d, %Y %I:%M %p"),
-                "Feedback": message.feedbacks.first().get_display_text()
-                if message.feedbacks.first()
-                else None,  # only show first feedback as per Sean's request
+                .strftime(settings.SHORT_DATETIME_FORMAT),
+                "Feedback": (
+                    message.feedbacks.first().get_display_text()
+                    if message.feedbacks.first()
+                    else None
+                ),  # only show first feedback as per Sean's request
                 "Analysis JSON": message.analysis_result,
+                "Run Time": (
+                    message.saved_run.run_time if message.saved_run else 0
+                ),  # user messages have no run/run_time
             }
             rows.append(row)
-        df = pd.DataFrame.from_records(rows)
+        df = pd.DataFrame.from_records(
+            rows,
+            columns=[
+                "Name",
+                "Role",
+                "Message (EN)",
+                "Sent",
+                "Feedback",
+                "Analysis JSON",
+                "Run Time",
+            ],
+        )
         return df
 
     def to_df_analysis_format(
@@ -916,24 +960,31 @@ def to_df_analysis_format(
     ) -> "pd.DataFrame":
         import pandas as pd
 
-        qs = self.filter(role=CHATML_ROLE_USER).prefetch_related("feedbacks")
+        qs = self.filter(role=CHATML_ROLE_ASSISSTANT).prefetch_related("feedbacks")
         rows = []
         for message in qs[:row_limit]:
             message: Message
             row = {
                 "Name": message.conversation.get_display_name(),
-                "Question (EN)": message.content,
-                "Answer (EN)": message.get_next_by_created_at().content,
+                "Question (EN)": message.get_previous_by_created_at().content,
+                "Answer (EN)": message.content,
                 "Sent": message.created_at.astimezone(tz)
                 .replace(tzinfo=None)
-                .strftime("%b %d, %Y %I:%M %p"),
+                .strftime(settings.SHORT_DATETIME_FORMAT),
                 "Analysis JSON": message.analysis_result,
             }
             rows.append(row)
-        df = pd.DataFrame.from_records(rows)
+        df = pd.DataFrame.from_records(
+            rows,
+            columns=["Name", "Question (EN)", "Answer (EN)", "Sent", "Analysis JSON"],
+        )
         return df
 
-    def as_llm_context(self, limit: int = 100) -> list["ConversationEntry"]:
+    def as_llm_context(
+        self, limit: int = 50, reset_at: datetime.datetime = None
+    ) -> list["ConversationEntry"]:
+        if reset_at:
+            self = self.filter(created_at__gt=reset_at)
         msgs = self.order_by("-created_at").prefetch_related("attachments")[:limit]
         entries = [None] * len(msgs)
         for i, msg in enumerate(reversed(msgs)):
@@ -1012,6 +1063,12 @@ class Message(models.Model):
         help_text="Subject of given question (DEPRECATED)",
     )
 
+    response_time = models.DurationField(
+        default=None,
+        null=True,
+        help_text="The time it took for the bot to respond to the corresponding user message",
+    )
+
     _analysis_started = False
 
     objects = MessageQuerySet.as_manager()
@@ -1102,20 +1159,33 @@ def to_df_format(
                 "Question Sent": feedback.message.get_previous_by_created_at()
                 .created_at.astimezone(tz)
                 .replace(tzinfo=None)
-                .strftime("%b %d, %Y %I:%M %p"),
+                .strftime(settings.SHORT_DATETIME_FORMAT),
                 "Answer (EN)": feedback.message.content,
                 "Answer Sent": feedback.message.created_at.astimezone(tz)
                 .replace(tzinfo=None)
-                .strftime("%b %d, %Y %I:%M %p"),
+                .strftime(settings.SHORT_DATETIME_FORMAT),
                 "Rating": Feedback.Rating(feedback.rating).label,
                 "Feedback (EN)": feedback.text_english,
                 "Feedback Sent": feedback.created_at.astimezone(tz)
                 .replace(tzinfo=None)
-                .strftime("%b %d, %Y %I:%M %p"),
+                .strftime(settings.SHORT_DATETIME_FORMAT),
                 "Question Answered": feedback.message.question_answered,
             }
             rows.append(row)
-        df = pd.DataFrame.from_records(rows)
+        df = pd.DataFrame.from_records(
+            rows,
+            columns=[
+                "Name",
+                "Question (EN)",
+                "Question Sent",
+                "Answer (EN)",
+                "Answer Sent",
+                "Rating",
+                "Feedback (EN)",
+                "Feedback Sent",
+                "Question Answered",
+            ],
+        )
         return df
 
 
diff --git a/bots/tasks.py b/bots/tasks.py
index 9afe2c343..4e00b4e78 100644
--- a/bots/tasks.py
+++ b/bots/tasks.py
@@ -1,4 +1,5 @@
 import json
+from json import JSONDecodeError
 
 from celery import shared_task
 from django.db.models import QuerySet
@@ -19,6 +20,7 @@
     SlackBot,
 )
 from daras_ai_v2.vector_search import references_as_prompt
+from gooeysite.bg_db_conn import get_celery_result_db_safe
 from recipes.VideoBots import ReplyButton
 
 
@@ -57,15 +59,22 @@ def msg_analysis(msg_id: int):
     Message.objects.filter(id=msg_id).update(analysis_run=sr)
 
     # wait for the result
-    result.get(disable_sync_subtasks=False)
+    get_celery_result_db_safe(result)
     sr.refresh_from_db()
     # if failed, raise error
     if sr.error_msg:
         raise RuntimeError(sr.error_msg)
 
     # save the result as json
+    output_text = flatten(sr.state["output_text"].values())[0]
+    try:
+        analysis_result = json.loads(output_text)
+    except JSONDecodeError:
+        analysis_result = {
+            "error": "Failed to parse the analysis result. Please check your script.",
+        }
     Message.objects.filter(id=msg_id).update(
-        analysis_result=json.loads(flatten(sr.state["output_text"].values())[0]),
+        analysis_result=analysis_result,
     )
 
 
@@ -128,7 +137,7 @@ def send_broadcast_msg(
                     channel_is_personal=convo.slack_channel_is_personal,
                     username=bi.name,
                     token=bi.slack_access_token,
-                )
+                )[0]
             case _:
                 raise NotImplementedError(
                     f"Platform {bi.platform} doesn't support broadcasts yet"
diff --git a/bots/tests.py b/bots/tests.py
index 21eef78f8..30105e648 100644
--- a/bots/tests.py
+++ b/bots/tests.py
@@ -92,3 +92,66 @@ def test_create_bot_integration_conversation_message(transactional_db):
     assert message_b.role == CHATML_ROLE_ASSISSTANT
     assert message_b.content == "Red, green, and yellow grow the best."
     assert message_b.display_content == "Red, green, and yellow grow the best."
+
+
+def test_stats_get_tabular_data_invalid_sorting_options(transactional_db):
+    from recipes.VideoBotsStats import VideoBotsStatsPage
+
+    page = VideoBotsStatsPage()
+
+    # setup
+    run_url = "https://my_run_url"
+    bi = BotIntegration.objects.create(
+        name="My Bot Integration",
+        saved_run=None,
+        billing_account_uid="fdnacsFSBQNKVW8z6tzhBLHKpAm1",  # digital green's account id
+        user_language="en",
+        show_feedback_buttons=True,
+        platform=Platform.WHATSAPP,
+        wa_phone_number="my_whatsapp_number",
+        wa_phone_number_id="my_whatsapp_number_id",
+    )
+    convos = Conversation.objects.filter(bot_integration=bi)
+    msgs = Message.objects.filter(conversation__in=convos)
+
+    # valid option but no data
+    df = page.get_tabular_data(
+        bi, run_url, convos, msgs, "Answered Successfully", "Name"
+    )
+    assert df.shape[0] == 0
+    assert "Name" in df.columns
+
+    # valid option and data
+    convo = Conversation.objects.create(
+        bot_integration=bi,
+        state=ConvoState.INITIAL,
+        wa_phone_number="+919876543210",
+    )
+    Message.objects.create(
+        conversation=convo,
+        role=CHATML_ROLE_USER,
+        content="What types of chilies can be grown in Mumbai?",
+        display_content="What types of chilies can be grown in Mumbai?",
+    )
+    Message.objects.create(
+        conversation=convo,
+        role=CHATML_ROLE_ASSISSTANT,
+        content="Red, green, and yellow grow the best.",
+        display_content="Red, green, and yellow grow the best.",
+        analysis_result={"Answered": True},
+    )
+    convos = Conversation.objects.filter(bot_integration=bi)
+    msgs = Message.objects.filter(conversation__in=convos)
+    assert msgs.count() == 2
+    df = page.get_tabular_data(
+        bi, run_url, convos, msgs, "Answered Successfully", "Name"
+    )
+    assert df.shape[0] == 1
+    assert "Name" in df.columns
+
+    # invalid sort option should be ignored
+    df = page.get_tabular_data(
+        bi, run_url, convos, msgs, "Answered Successfully", "Invalid"
+    )
+    assert df.shape[0] == 1
+    assert "Name" in df.columns
diff --git a/celeryapp/tasks.py b/celeryapp/tasks.py
index 1868c7a18..a4a6ffe07 100644
--- a/celeryapp/tasks.py
+++ b/celeryapp/tasks.py
@@ -1,21 +1,30 @@
+import datetime
+import html
 import traceback
 import typing
 from time import time
 from types import SimpleNamespace
 
+import requests
 import sentry_sdk
+from django.db.models import Sum
+from django.utils import timezone
+from fastapi import HTTPException
 
 import gooey_ui as st
-from app_users.models import AppUser
+from app_users.models import AppUser, AppUserTransaction
 from bots.models import SavedRun
 from celeryapp.celeryconfig import app
 from daras_ai.image_input import truncate_text_words
 from daras_ai_v2 import settings
-from daras_ai_v2.base import StateKeys, err_msg_for_exc, BasePage
+from daras_ai_v2.base import StateKeys, BasePage
+from daras_ai_v2.exceptions import UserError
 from daras_ai_v2.send_email import send_email_via_postmark
+from daras_ai_v2.send_email import send_low_balance_email
 from daras_ai_v2.settings import templates
 from gooey_ui.pubsub import realtime_push
 from gooey_ui.state import set_query_params
+from gooeysite.bg_db_conn import db_middleware, next_db_safe
 
 
 @app.task
@@ -31,7 +40,19 @@ def gui_runner(
     is_api_call: bool = False,
 ):
     page = page_cls(request=SimpleNamespace(user=AppUser.objects.get(id=user_id)))
+
+    def event_processor(event, hint):
+        event["request"] = {
+            "method": "POST",
+            "url": page.app_url(query_params=query_params),
+            "data": state,
+        }
+        return event
+
+    page.setup_sentry(event_processor=event_processor)
+
     sr = page.run_doc_sr(run_id, uid)
+    sr.is_api_call = is_api_call
 
     st.set_session_state(state)
     run_time = 0
@@ -39,6 +60,7 @@ def gui_runner(
     error_msg = None
     set_query_params(query_params or {})
 
+    @db_middleware
     def save(done=False):
         if done:
             # clear run status
@@ -80,7 +102,7 @@ def save(done=False):
             start_time = time()
             try:
                 # advance the generator (to further progress of run())
-                yield_val = next(gen)
+                yield_val = next_db_safe(gen)
                 # increment total time taken after every iteration
                 run_time += time() - start_time
                 continue
@@ -92,8 +114,25 @@ def save(done=False):
             # render errors nicely
             except Exception as e:
                 run_time += time() - start_time
-                traceback.print_exc()
-                sentry_sdk.capture_exception(e)
+
+                if isinstance(e, HTTPException) and e.status_code == 402:
+                    error_msg = page.generate_credit_error_message(
+                        example_id=query_params.get("example_id"),
+                        run_id=run_id,
+                        uid=uid,
+                    )
+                    try:
+                        raise UserError(error_msg) from e
+                    except UserError as e:
+                        sentry_sdk.capture_exception(e, level=e.sentry_level)
+                        break
+
+                if isinstance(e, UserError):
+                    sentry_level = e.sentry_level
+                else:
+                    sentry_level = "error"
+                    traceback.print_exc()
+                sentry_sdk.capture_exception(e, level=sentry_level)
                 error_msg = err_msg_for_exc(e)
                 break
             finally:
@@ -102,6 +141,69 @@ def save(done=False):
         save(done=True)
         if not is_api_call:
             send_email_on_completion(page, sr)
+        run_low_balance_email_check(uid)
+
+
+def err_msg_for_exc(e: Exception):
+    if isinstance(e, requests.HTTPError):
+        response: requests.Response = e.response
+        try:
+            err_body = response.json()
+        except requests.JSONDecodeError:
+            err_str = response.text
+        else:
+            format_exc = err_body.get("format_exc")
+            if format_exc:
+                print("⚡️ " + format_exc)
+            err_type = err_body.get("type")
+            err_str = err_body.get("str")
+            if err_type and err_str:
+                return f"(GPU) {err_type}: {err_str}"
+            err_str = str(err_body)
+        return f"(HTTP {response.status_code}) {html.escape(err_str[:1000])}"
+    elif isinstance(e, HTTPException):
+        return f"(HTTP {e.status_code}) {e.detail})"
+    elif isinstance(e, UserError):
+        return e.message
+    else:
+        return f"{type(e).__name__}: {e}"
+
+
+def run_low_balance_email_check(uid: str):
+    # don't send email if feature is disabled
+    if not settings.LOW_BALANCE_EMAIL_ENABLED:
+        return
+    user = AppUser.objects.get(uid=uid)
+    # don't send email if user is not paying or has enough balance
+    if not user.is_paying or user.balance > settings.LOW_BALANCE_EMAIL_CREDITS:
+        return
+    last_purchase = (
+        AppUserTransaction.objects.filter(user=user, amount__gt=0)
+        .order_by("-created_at")
+        .first()
+    )
+    email_date_cutoff = timezone.now() - datetime.timedelta(
+        days=settings.LOW_BALANCE_EMAIL_DAYS
+    )
+    # send email if user has not been sent email in last X days or last purchase was after last email sent
+    if (
+        # user has not been sent any email
+        not user.low_balance_email_sent_at
+        # user was sent email before X days
+        or (user.low_balance_email_sent_at < email_date_cutoff)
+        # user has made a purchase after last email sent
+        or (last_purchase and last_purchase.created_at > user.low_balance_email_sent_at)
+    ):
+        # calculate total credits consumed in last X days
+        total_credits_consumed = abs(
+            AppUserTransaction.objects.filter(
+                user=user, amount__lt=0, created_at__gte=email_date_cutoff
+            ).aggregate(Sum("amount"))["amount__sum"]
+            or 0
+        )
+        send_low_balance_email(user=user, total_credits_consumed=total_credits_consumed)
+        user.low_balance_email_sent_at = timezone.now()
+        user.save(update_fields=["low_balance_email_sent_at"])
 
 
 def send_email_on_completion(page: BasePage, sr: SavedRun):
diff --git a/conftest.py b/conftest.py
index e8534d5f2..f2003dc0c 100644
--- a/conftest.py
+++ b/conftest.py
@@ -9,6 +9,22 @@
 from auth import auth_backend
 from celeryapp import app
 from daras_ai_v2.base import BasePage
+from daras_ai_v2.send_email import pytest_outbox
+
+
+def flaky(fn):
+    max_tries = 5
+
+    @wraps(fn)
+    def wrapper(*args, **kwargs):
+        for i in range(max_tries):
+            try:
+                return fn(*args, **kwargs)
+            except Exception:
+                if i == max_tries - 1:
+                    raise
+
+    return wrapper
 
 
 @pytest.fixture(scope="session")
@@ -44,11 +60,12 @@ def _mock_gui_runner(
 
 
 @pytest.fixture
-def threadpool_subtest(subtests, max_workers: int = 8):
+def threadpool_subtest(subtests, max_workers: int = 128):
     ts = []
 
-    def submit(fn, *args, **kwargs):
-        msg = "--".join(map(str, [*args, *kwargs.values()]))
+    def submit(fn, *args, msg=None, **kwargs):
+        if not msg:
+            msg = "--".join(map(str, [*args, *kwargs.values()]))
 
         @wraps(fn)
         def runner(*args, **kwargs):
@@ -67,6 +84,11 @@ def runner(*args, **kwargs):
             t.join()
 
 
+@pytest.fixture(autouse=True)
+def clear_pytest_outbox():
+    pytest_outbox.clear()
+
+
 # class DummyDatabaseBlocker(pytest_django.plugin._DatabaseBlocker):
 #     class _dj_db_wrapper:
 #         def ensure_connection(self):
diff --git a/daras_ai/extract_face.py b/daras_ai/extract_face.py
index e81b35d6e..aeb107a45 100644
--- a/daras_ai/extract_face.py
+++ b/daras_ai/extract_face.py
@@ -1,5 +1,7 @@
 import numpy as np
 
+from daras_ai_v2.exceptions import UserError
+
 
 def extract_and_reposition_face_cv2(
     orig_img,
@@ -118,7 +120,7 @@ def face_oval_hull_generator(image_cv2):
         results = face_mesh.process(cv2.cvtColor(image_cv2, cv2.COLOR_BGR2RGB))
 
         if not results.multi_face_landmarks:
-            raise ValueError("Face not found")
+            raise UserError("Face not found")
 
         for landmark_list in results.multi_face_landmarks:
             idx_to_coordinates = build_idx_to_coordinates_dict(
diff --git a/daras_ai/image_input.py b/daras_ai/image_input.py
index 2a7a70417..5e61fcba9 100644
--- a/daras_ai/image_input.py
+++ b/daras_ai/image_input.py
@@ -11,6 +11,7 @@
 from furl import furl
 
 from daras_ai_v2 import settings
+from daras_ai_v2.exceptions import UserError
 
 
 def resize_img_pad(img_bytes: bytes, size: tuple[int, int]) -> bytes:
@@ -90,7 +91,7 @@ def bytes_to_cv2_img(img_bytes: bytes, greyscale=False) -> np.ndarray:
         flags = cv2.IMREAD_COLOR
     img_cv2 = cv2.imdecode(np.frombuffer(img_bytes, dtype=np.uint8), flags=flags)
     if not img_exists(img_cv2):
-        raise ValueError("Bad Image")
+        raise UserError("Bad Image")
     return img_cv2
 
 
@@ -112,7 +113,9 @@ def safe_filename(filename: str) -> str:
     return out
 
 
-def truncate_filename(text: str, maxlen: int = 100, sep: str = "...") -> str:
+def truncate_filename(
+    text: str | bytes, maxlen: int = 100, sep: str | bytes = "..."
+) -> str | bytes:
     if len(text) <= maxlen:
         return text
     assert len(sep) <= maxlen
diff --git a/daras_ai_v2/asr.py b/daras_ai_v2/asr.py
index 81562a49f..4403dd32b 100644
--- a/daras_ai_v2/asr.py
+++ b/daras_ai_v2/asr.py
@@ -1,9 +1,7 @@
-import json
 import os.path
-import subprocess
+import os.path
 import tempfile
 from enum import Enum
-from time import sleep
 
 import langcodes
 import requests
@@ -14,7 +12,14 @@
 import gooey_ui as st
 from daras_ai.image_input import upload_file_from_bytes, gs_url_to_uri
 from daras_ai_v2 import settings
-from daras_ai_v2.exceptions import raise_for_status
+from daras_ai_v2.azure_asr import azure_asr
+from daras_ai_v2.exceptions import (
+    raise_for_status,
+    UserError,
+    ffmpeg,
+    call_cmd,
+    ffprobe,
+)
 from daras_ai_v2.functional import map_parallel
 from daras_ai_v2.gdrive_downloader import (
     is_gdrive_url,
@@ -22,25 +27,75 @@
     gdrive_metadata,
     url_to_gdrive_file_id,
 )
+from daras_ai_v2.google_asr import gcp_asr_v1
 from daras_ai_v2.gpu_server import call_celery_task
 from daras_ai_v2.redis_cache import redis_cache_decorator
 
 SHORT_FILE_CUTOFF = 5 * 1024 * 1024  # 1 MB
 
-
 TRANSLITERATION_SUPPORTED = {"ar", "bn", " gu", "hi", "ja", "kn", "ru", "ta", "te"}
 
-# below CHIRP list was found experimentally since the supported languages list by google is actually wrong:
-CHIRP_SUPPORTED = {"af-ZA", "sq-AL", "am-ET", "ar-EG", "hy-AM", "as-IN", "ast-ES", "az-AZ", "eu-ES", "be-BY", "bs-BA", "bg-BG", "my-MM", "ca-ES", "ceb-PH", "ckb-IQ", "zh-Hans-CN", "yue-Hant-HK", "hr-HR", "cs-CZ", "da-DK", "nl-NL", "en-AU", "en-IN", "en-GB", "en-US", "et-EE", "fil-PH", "fi-FI", "fr-CA", "fr-FR", "gl-ES", "ka-GE", "de-DE", "el-GR", "gu-IN", "ha-NG", "iw-IL", "hi-IN", "hu-HU", "is-IS", "id-ID", "it-IT", "ja-JP", "jv-ID", "kea-CV", "kam-KE", "kn-IN", "kk-KZ", "km-KH", "ko-KR", "ky-KG", "lo-LA", "lv-LV", "ln-CD", "lt-LT", "luo-KE", "lb-LU", "mk-MK", "ms-MY", "ml-IN", "mt-MT", "mi-NZ", "mr-IN", "mn-MN", "ne-NP", "ny-MW", "oc-FR", "ps-AF", "fa-IR", "pl-PL", "pt-BR", "pa-Guru-IN", "ro-RO", "ru-RU", "nso-ZA", "sr-RS", "sn-ZW", "sd-IN", "si-LK", "sk-SK", "sl-SI", "so-SO", "es-ES", "es-US", "su-ID", "sw", "sv-SE", "tg-TJ", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "uz-UZ", "vi-VN", "cy-GB", "wo-SN", "yo-NG", "zu-ZA"}  # fmt: skip
-
-WHISPER_SUPPORTED = {"af", "ar", "hy", "az", "be", "bs", "bg", "ca", "zh", "hr", "cs", "da", "nl", "en", "et", "fi", "fr", "gl", "de", "el", "he", "hi", "hu", "is", "id", "it", "ja", "kn", "kk", "ko", "lv", "lt", "mk", "ms", "mr", "mi", "ne", "no", "fa", "pl", "pt", "ro", "ru", "sr", "sk", "sl", "es", "sw", "sv", "tl", "ta", "th", "tr", "uk", "ur", "vi", "cy"}  # fmt: skip
+# https://cloud.google.com/speech-to-text/docs/speech-to-text-supported-languages
+GCP_V1_SUPPORTED = {
+    "af-ZA", "sq-AL", "am-ET", "ar-DZ", "ar-BH", "ar-EG", "ar-IQ", "ar-IL", "ar-JO", "ar-KW", "ar-LB", "ar-MR", "ar-MA",
+    "ar-OM", "ar-QA", "ar-SA", "ar-PS", "ar-SY", "ar-TN", "ar-AE", "ar-YE", "hy-AM", "az-AZ", "eu-ES", "bn-BD", "bn-IN",
+    "bs-BA", "bg-BG", "my-MM", "ca-ES", "yue-Hant-HK", "zh", "zh-TW", "hr-HR", "cs-CZ",
+    "da-DK", "nl-BE", "nl-NL", "en-AU", "en-CA", "en-GH", "en-HK", "en-IN", "en-IE", "en-KE", "en-NZ", "en-NG", "en-PK",
+    "en-PH", "en-SG", "en-ZA", "en-TZ", "en-GB", "en-US", "et-EE", "fil-PH", "fi-FI", "fr-BE", "fr-CA", "fr-FR",
+    "fr-CH", "gl-ES", "ka-GE", "de-AT", "de-DE", "de-CH", "el-GR", "gu-IN", "iw-IL", "hi-IN", "hu-HU", "is-IS", "id-ID",
+    "it-IT", "it-CH", "ja-JP", "jv-ID", "kn-IN", "kk-KZ", "km-KH", "ko-KR", "lo-LA", "lv-LV", "lt-LT", "mk-MK", "ms-MY",
+    "ml-IN", "mr-IN", "mn-MN", "ne-NP", "no-NO", "fa-IR", "pl-PL", "pt-BR", "pt-PT", "pa-Guru-IN", "ro-RO", "ru-RU",
+    "sr-RS", "si-LK", "sk-SK", "sl-SI", "es-AR", "es-BO", "es-CL", "es-CO", "es-CR", "es-DO", "es-EC", "es-SV", "es-GT",
+    "es-HN", "es-MX", "es-NI", "es-PA", "es-PY", "es-PE", "es-PR", "es-ES", "es-US", "es-UY", "es-VE", "su-ID", "sw-KE",
+    "sw-TZ", "sv-SE", "ta-IN", "ta-MY", "ta-SG", "ta-LK", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-IN", "ur-PK", "uz-UZ",
+    "vi-VN", "zu-ZA",
+}  # fmt: skip
+
+# https://cloud.google.com/speech-to-text/v2/docs/speech-to-text-supported-languages
+CHIRP_SUPPORTED = {
+    "af-ZA", "sq-AL", "am-ET", "ar-EG", "hy-AM", "as-IN", "ast-ES", "az-AZ", "eu-ES", "be-BY", "bs-BA", "bg-BG",
+    "my-MM", "ca-ES", "ceb-PH", "ckb-IQ", "yue-Hant-HK", "zh-TW", "hr-HR", "cs-CZ", "da-DK", "nl-NL",
+    "en-AU", "en-IN", "en-GB", "en-US", "et-EE", "fil-PH", "fi-FI", "fr-CA", "fr-FR", "gl-ES", "ka-GE", "de-DE",
+    "el-GR", "gu-IN", "ha-NG", "iw-IL", "hi-IN", "hu-HU", "is-IS", "id-ID", "it-IT", "ja-JP", "jv-ID", "kea-CV",
+    "kam-KE", "kn-IN", "kk-KZ", "km-KH", "ko-KR", "ky-KG", "lo-LA", "lv-LV", "ln-CD", "lt-LT", "luo-KE", "lb-LU",
+    "mk-MK", "ms-MY", "ml-IN", "mt-MT", "mi-NZ", "mr-IN", "mn-MN", "ne-NP", "no-NO", "ny-MW", "oc-FR", "ps-AF", "fa-IR",
+    "pl-PL", "pt-BR", "pa-Guru-IN", "ro-RO", "ru-RU", "nso-ZA", "sr-RS", "sn-ZW", "sd-IN", "si-LK", "sk-SK", "sl-SI",
+    "so-SO", "es-ES", "es-US", "su-ID", "sw", "sv-SE", "tg-TJ", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK",
+    "uz-UZ", "vi-VN", "cy-GB", "wo-SN", "yo-NG", "zu-ZA"
+}  # fmt: skip
+
+WHISPER_SUPPORTED = {
+    "af", "ar", "hy", "az", "be", "bs", "bg", "ca", "zh", "hr", "cs", "da", "nl", "en", "et", "fi", "fr", "gl", "de",
+    "el", "he", "hi", "hu", "is", "id", "it", "ja", "kn", "kk", "ko", "lv", "lt", "mk", "ms", "mr", "mi", "ne", "no",
+    "fa", "pl", "pt", "ro", "ru", "sr", "sk", "sl", "es", "sw", "sv", "tl", "ta", "th", "tr", "uk", "ur", "vi", "cy"
+}  # fmt: skip
 
 # See page 14 of https://scontent-sea1-1.xx.fbcdn.net/v/t39.2365-6/369747868_602316515432698_2401716319310287708_n.pdf?_nc_cat=106&ccb=1-7&_nc_sid=3c67a6&_nc_ohc=_5cpNOcftdYAX8rCrVo&_nc_ht=scontent-sea1-1.xx&oh=00_AfDVkx7XubifELxmB_Un-yEYMJavBHFzPnvTbTlalbd_1Q&oe=65141B39
 # For now, below are listed the languages that support ASR. Note that Seamless only accepts ISO 639-3 codes.
-SEAMLESS_SUPPORTED = {"afr", "amh", "arb", "ary", "arz", "asm", "ast", "azj", "bel", "ben", "bos", "bul", "cat", "ceb", "ces", "ckb", "cmn", "cym", "dan", "deu", "ell", "eng", "est", "eus", "fin", "fra", "gaz", "gle", "glg", "guj", "heb", "hin", "hrv", "hun", "hye", "ibo", "ind", "isl", "ita", "jav", "jpn", "kam", "kan", "kat", "kaz", "kea", "khk", "khm", "kir", "kor", "lao", "lit", "ltz", "lug", "luo", "lvs", "mai", "mal", "mar", "mkd", "mlt", "mni", "mya",  "nld", "nno", "nob", "npi", "nya", "oci", "ory", "pan", "pbt", "pes", "pol", "por", "ron", "rus", "slk", "slv", "sna", "snd", "som", "spa", "srp", "swe", "swh", "tam", "tel", "tgk", "tgl", "tha", "tur", "ukr", "urd", "uzn", "vie", "xho", "yor", "yue", "zlm", "zul"}  # fmt: skip
-
-AZURE_SUPPORTED = {"af-ZA", "am-ET", "ar-AE", "ar-BH", "ar-DZ", "ar-EG", "ar-IL", "ar-IQ", "ar-JO", "ar-KW", "ar-LB", "ar-LY", "ar-MA", "ar-OM", "ar-PS", "ar-QA", "ar-SA", "ar-SY", "ar-TN", "ar-YE", "az-AZ", "bg-BG", "bn-IN", "bs-BA", "ca-ES", "cs-CZ", "cy-GB", "da-DK", "de-AT", "de-CH", "de-DE", "el-GR", "en-AU", "en-CA", "en-GB", "en-GH", "en-HK", "en-IE", "en-IN", "en-KE", "en-NG", "en-NZ", "en-PH", "en-SG", "en-TZ", "en-US", "en-ZA", "es-AR", "es-BO", "es-CL", "es-CO", "es-CR", "es-CU", "es-DO", "es-EC", "es-ES", "es-GQ", "es-GT", "es-HN", "es-MX", "es-NI", "es-PA", "es-PE", "es-PR", "es-PY", "es-SV", "es-US", "es-UY", "es-VE", "et-EE", "eu-ES", "fa-IR", "fi-FI", "fil-PH", "fr-BE", "fr-CA", "fr-CH", "fr-FR", "ga-IE", "gl-ES", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "hy-AM", "id-ID", "is-IS", "it-CH", "it-IT", "ja-JP", "jv-ID", "ka-GE", "kk-KZ", "km-KH", "kn-IN", "ko-KR", "lo-LA", "lt-LT", "lv-LV", "mk-MK", "ml-IN", "mn-MN", "mr-IN", "ms-MY", "mt-MT", "my-MM", "nb-NO", "ne-NP", "nl-BE", "nl-NL", "pa-IN", "pl-PL", "ps-AF", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "si-LK", "sk-SK", "sl-SI", "so-SO", "sq-AL", "sr-RS", "sv-SE", "sw-KE", "sw-TZ", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-IN", "uz-UZ", "vi-VN", "wuu-CN", "yue-CN", "zh-CN", "zh-CN-shandong", "zh-CN-sichuan", "zh-HK", "zh-TW", "zu-ZA"}  # fmt: skip
-MAX_POLLS = 100
+SEAMLESS_SUPPORTED = {
+    "afr", "amh", "arb", "ary", "arz", "asm", "ast", "azj", "bel", "ben", "bos", "bul", "cat", "ceb", "ces", "ckb",
+    "cmn", "cym", "dan", "deu", "ell", "eng", "est", "eus", "fin", "fra", "gaz", "gle", "glg", "guj", "heb", "hin",
+    "hrv", "hun", "hye", "ibo", "ind", "isl", "ita", "jav", "jpn", "kam", "kan", "kat", "kaz", "kea", "khk", "khm",
+    "kir", "kor", "lao", "lit", "ltz", "lug", "luo", "lvs", "mai", "mal", "mar", "mkd", "mlt", "mni", "mya", "nld",
+    "nno", "nob", "npi", "nya", "oci", "ory", "pan", "pbt", "pes", "pol", "por", "ron", "rus", "slk", "slv", "sna",
+    "snd", "som", "spa", "srp", "swe", "swh", "tam", "tel", "tgk", "tgl", "tha", "tur", "ukr", "urd", "uzn", "vie",
+    "xho", "yor", "yue", "zlm", "zul"
+}  # fmt: skip
+
+AZURE_SUPPORTED = {
+    "af-ZA", "am-ET", "ar-AE", "ar-BH", "ar-DZ", "ar-EG", "ar-IL", "ar-IQ", "ar-JO", "ar-KW", "ar-LB", "ar-LY", "ar-MA",
+    "ar-OM", "ar-PS", "ar-QA", "ar-SA", "ar-SY", "ar-TN", "ar-YE", "az-AZ", "bg-BG", "bn-IN", "bs-BA", "ca-ES", "cs-CZ",
+    "cy-GB", "da-DK", "de-AT", "de-CH", "de-DE", "el-GR", "en-AU", "en-CA", "en-GB", "en-GH", "en-HK", "en-IE", "en-IN",
+    "en-KE", "en-NG", "en-NZ", "en-PH", "en-SG", "en-TZ", "en-US", "en-ZA", "es-AR", "es-BO", "es-CL", "es-CO", "es-CR",
+    "es-CU", "es-DO", "es-EC", "es-ES", "es-GQ", "es-GT", "es-HN", "es-MX", "es-NI", "es-PA", "es-PE", "es-PR", "es-PY",
+    "es-SV", "es-US", "es-UY", "es-VE", "et-EE", "eu-ES", "fa-IR", "fi-FI", "fil-PH", "fr-BE", "fr-CA", "fr-CH",
+    "fr-FR", "ga-IE", "gl-ES", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "hy-AM", "id-ID", "is-IS", "it-CH", "it-IT",
+    "ja-JP", "jv-ID", "ka-GE", "kk-KZ", "km-KH", "kn-IN", "ko-KR", "lo-LA", "lt-LT", "lv-LV", "mk-MK", "ml-IN", "mn-MN",
+    "mr-IN", "ms-MY", "mt-MT", "my-MM", "nb-NO", "ne-NP", "nl-BE", "nl-NL", "pa-IN", "pl-PL", "ps-AF", "pt-BR", "pt-PT",
+    "ro-RO", "ru-RU", "si-LK", "sk-SK", "sl-SI", "so-SO", "sq-AL", "sr-RS", "sv-SE", "sw-KE", "sw-TZ", "ta-IN", "te-IN",
+    "th-TH", "tr-TR", "uk-UA", "ur-IN", "uz-UZ", "vi-VN", "wuu-CN", "yue-CN", "zh-CN", "zh-CN-shandong",
+    "zh-CN-sichuan", "zh-HK", "zh-TW", "zu-ZA"
+}  # fmt: skip
 
 # https://deepgram.com/product/languages for the "general" model:
 # DEEPGRAM_SUPPORTED = {"nl","en","en-AU","en-US","en-GB","en-NZ","en-IN","fr","fr-CA","de","hi","hi-Latn","id","it","ja","ko","cmn-Hans-CN","cmn-Hant-TW","no","pl","pt","pt-PT","pt-BR","ru","es","es-419","sv","tr","uk"}  # fmt: skip
@@ -56,15 +111,14 @@ class AsrModels(Enum):
     nemo_english = "Conformer English (ai4bharat.org)"
     nemo_hindi = "Conformer Hindi (ai4bharat.org)"
     vakyansh_bhojpuri = "Vakyansh Bhojpuri (Open-Speech-EkStep)"
-    usm = "Chirp / USM (Google)"
+    gcp_v1 = "Google Cloud V1"
+    usm = "Chirp / USM (Google V2)"
     deepgram = "Deepgram"
     azure = "Azure Speech"
     seamless_m4t = "Seamless M4T (Facebook Research)"
 
     def supports_auto_detect(self) -> bool:
-        return self not in {
-            self.azure,
-        }
+        return self not in {self.azure, self.gcp_v1}
 
 
 asr_model_ids = {
@@ -89,6 +143,7 @@ def supports_auto_detect(self) -> bool:
 asr_supported_languages = {
     AsrModels.whisper_large_v3: WHISPER_SUPPORTED,
     AsrModels.whisper_large_v2: WHISPER_SUPPORTED,
+    AsrModels.gcp_v1: GCP_V1_SUPPORTED,
     AsrModels.usm: CHIRP_SUPPORTED,
     AsrModels.deepgram: DEEPGRAM_SUPPORTED,
     AsrModels.seamless_m4t: SEAMLESS_SUPPORTED,
@@ -128,7 +183,7 @@ def google_translate_language_selector(
         label: the label to display
         key: the key to save the selected language to in the session state
     """
-    languages = google_translate_languages()
+    languages = google_translate_target_languages()
     options = list(languages.keys())
     if allow_none:
         options.insert(0, None)
@@ -141,8 +196,8 @@ def google_translate_language_selector(
     )
 
 
-@redis_cache_decorator
-def google_translate_languages() -> dict[str, str]:
+@redis_cache_decorator(ex=settings.REDIS_MODELS_CACHE_EXPIRY)
+def google_translate_target_languages() -> dict[str, str]:
     """
     Get list of supported languages for Google Translate.
     :return: Dictionary of language codes and display names.
@@ -162,8 +217,8 @@ def google_translate_languages() -> dict[str, str]:
     }
 
 
-@redis_cache_decorator
-def google_translate_input_languages() -> dict[str, str]:
+@redis_cache_decorator(ex=settings.REDIS_MODELS_CACHE_EXPIRY)
+def google_translate_source_languages() -> dict[str, str]:
     """
     Get list of supported languages for Google Translate.
     :return: Dictionary of language codes and display names.
@@ -246,11 +301,11 @@ def run_google_translate(
     if source_language:
         source_language = langcodes.Language.get(source_language).to_tag()
         source_language = get_language_in_collection(
-            source_language, google_translate_input_languages().keys()
+            source_language, google_translate_source_languages().keys()
         )  # this will default to autodetect if language is not found as supported
     target_language = langcodes.Language.get(target_language).to_tag()
     target_language: str | None = get_language_in_collection(
-        target_language, google_translate_languages().keys()
+        target_language, google_translate_target_languages().keys()
     )
     if not target_language:
         raise ValueError(f"Unsupported target language: {target_language!r}")
@@ -467,6 +522,8 @@ def run_asr(
                 src_lang=language,
             ),
         )
+    elif selected_model == AsrModels.gcp_v1:
+        return gcp_asr_v1(audio_url, language)
     elif selected_model == AsrModels.usm:
         location = settings.GCP_REGION
 
@@ -575,7 +632,7 @@ def run_asr(
             assert data.get("chunks"), f"{selected_model.value} can't generate VTT"
             return generate_vtt(data["chunks"])
         case _:
-            raise ValueError(f"Invalid output format: {output_format}")
+            raise UserError(f"Invalid output format: {output_format}")
 
 
 def _get_or_create_recognizer(
@@ -611,64 +668,6 @@ def _get_or_create_recognizer(
     return recognizer
 
 
-def azure_asr(audio_url: str, language: str):
-    # transcription from audio url only supported via rest api or cli
-    # Start by initializing a request
-    payload = {
-        "contentUrls": [
-            audio_url,
-        ],
-        "displayName": "Gooey Transcription",
-        "model": None,
-        "properties": {
-            "wordLevelTimestampsEnabled": False,
-        },
-        "locale": language or "en-US",
-    }
-    r = requests.post(
-        str(furl(settings.AZURE_SPEECH_ENDPOINT) / "speechtotext/v3.1/transcriptions"),
-        headers={
-            "Ocp-Apim-Subscription-Key": settings.AZURE_SPEECH_KEY,
-            "Content-Type": "application/json",
-        },
-        json=payload,
-    )
-    raise_for_status(r)
-    uri = r.json()["self"]
-
-    # poll for results
-    for _ in range(MAX_POLLS):
-        r = requests.get(
-            uri,
-            headers={
-                "Ocp-Apim-Subscription-Key": settings.AZURE_SPEECH_KEY,
-            },
-        )
-        if not r.ok or not r.json()["status"] == "Succeeded":
-            sleep(5)
-            continue
-        r = requests.get(
-            r.json()["links"]["files"],
-            headers={
-                "Ocp-Apim-Subscription-Key": settings.AZURE_SPEECH_KEY,
-            },
-        )
-        raise_for_status(r)
-        transcriptions = []
-        for value in r.json()["values"]:
-            if value["kind"] != "Transcription":
-                continue
-            r = requests.get(
-                value["links"]["contentUrl"],
-                headers={"Ocp-Apim-Subscription-Key": settings.AZURE_SPEECH_KEY},
-            )
-            raise_for_status(r)
-            combined_phrases = r.json().get("combinedRecognizedPhrases") or [{}]
-            transcriptions += [combined_phrases[0].get("display", "")]
-        return "\n".join(transcriptions)
-    assert False, "Max polls exceeded, Azure speech did not yield a response"
-
-
 # 16kHz, 16-bit, mono
 FFMPEG_WAV_ARGS = ["-vn", "-acodec", "pcm_s16le", "-ac", "1", "-ar", "16000"]
 
@@ -683,7 +682,7 @@ def download_youtube_to_wav(youtube_url: str) -> tuple[str, int]:
         infile = os.path.join(tmpdir, "infile")
         outfile = os.path.join(tmpdir, "outfile.wav")
         # run yt-dlp to download audio
-        args = [
+        call_cmd(
             "yt-dlp",
             "--no-playlist",
             "--format",
@@ -691,13 +690,9 @@ def download_youtube_to_wav(youtube_url: str) -> tuple[str, int]:
             "--output",
             infile,
             youtube_url,
-        ]
-        print("\t$ " + " ".join(args))
-        subprocess.check_call(args)
+        )
         # convert audio to single channel wav
-        args = ["ffmpeg", "-y", "-i", infile, *FFMPEG_WAV_ARGS, outfile]
-        print("\t$ " + " ".join(args))
-        subprocess.check_call(args)
+        ffmpeg("-i", infile, *FFMPEG_WAV_ARGS, outfile)
         # read wav file into memory
         with open(outfile, "rb") as f:
             wavdata = f.read()
@@ -728,43 +723,12 @@ def audio_bytes_to_wav(audio_bytes: bytes) -> tuple[bytes | None, int]:
 
         with tempfile.NamedTemporaryFile(suffix=".wav") as outfile:
             # convert audio to single channel wav
-            args = [
-                "ffmpeg",
-                "-y",
-                "-i",
-                infile.name,
-                *FFMPEG_WAV_ARGS,
-                outfile.name,
-            ]
-            print("\t$ " + " ".join(args))
-            try:
-                subprocess.check_output(args, stderr=subprocess.STDOUT)
-            except subprocess.CalledProcessError as e:
-                ffmpeg_output_error = ValueError(e.output, e)
-                raise ValueError(
-                    "Invalid audio file. Could not convert audio to wav format. Please confirm the file is not corrupted and has a supported format (google 'ffmpeg supported audio file types')"
-                ) from ffmpeg_output_error
+            ffmpeg("-i", infile.name, *FFMPEG_WAV_ARGS, outfile.name)
             return outfile.read(), os.path.getsize(outfile.name)
 
 
 def check_wav_audio_format(filename: str) -> bool:
-    args = [
-        "ffprobe",
-        "-v",
-        "quiet",
-        "-print_format",
-        "json",
-        "-show_streams",
-        filename,
-    ]
-    print("\t$ " + " ".join(args))
-    try:
-        data = json.loads(subprocess.check_output(args, stderr=subprocess.STDOUT))
-    except subprocess.CalledProcessError as e:
-        ffmpeg_output_error = ValueError(e.output, e)
-        raise ValueError(
-            "Invalid audio file. Please confirm the file is not corrupted and has a supported format (google 'ffmpeg supported audio file types')"
-        ) from ffmpeg_output_error
+    data = ffprobe(filename)
     return (
         len(data["streams"]) == 1
         and data["streams"][0]["codec_name"] == "pcm_s16le"
diff --git a/daras_ai_v2/azure_asr.py b/daras_ai_v2/azure_asr.py
new file mode 100644
index 000000000..aed873b03
--- /dev/null
+++ b/daras_ai_v2/azure_asr.py
@@ -0,0 +1,96 @@
+import datetime
+from time import sleep
+
+import requests
+from furl import furl
+
+from daras_ai_v2 import settings
+from daras_ai_v2.exceptions import (
+    raise_for_status,
+)
+from daras_ai_v2.redis_cache import redis_cache_decorator
+
+# 20 mins timeout
+MAX_POLLS = 200
+POLL_INTERVAL = 6
+
+
+def azure_asr(audio_url: str, language: str):
+    # Start by initializing a request
+    # https://eastus.dev.cognitive.microsoft.com/docs/services/speech-to-text-api-v3-1/operations/Transcriptions_Create
+    language = language or "en-US"
+    r = requests.post(
+        str(furl(settings.AZURE_SPEECH_ENDPOINT) / "speechtotext/v3.1/transcriptions"),
+        headers=azure_auth_header(),
+        json={
+            "contentUrls": [audio_url],
+            "displayName": f"Gooey Transcription {datetime.datetime.now().isoformat()} {language=} {audio_url=}",
+            "model": azure_get_latest_model(language),
+            "properties": {
+                "wordLevelTimestampsEnabled": False,
+                # "displayFormWordLevelTimestampsEnabled": True,
+                # "diarizationEnabled": False,
+                # "punctuationMode": "DictatedAndAutomatic",
+                # "profanityFilterMode": "Masked",
+            },
+            "locale": language,
+        },
+    )
+    raise_for_status(r)
+    uri = r.json()["self"]
+
+    # poll for results
+    for _ in range(MAX_POLLS):
+        r = requests.get(uri, headers=azure_auth_header())
+        if not r.ok or not r.json()["status"] == "Succeeded":
+            sleep(POLL_INTERVAL)
+            continue
+        r = requests.get(r.json()["links"]["files"], headers=azure_auth_header())
+        raise_for_status(r)
+        transcriptions = []
+        for value in r.json()["values"]:
+            if value["kind"] != "Transcription":
+                continue
+            r = requests.get(value["links"]["contentUrl"], headers=azure_auth_header())
+            raise_for_status(r)
+            combined_phrases = r.json().get("combinedRecognizedPhrases") or [{}]
+            transcriptions += [combined_phrases[0].get("display", "")]
+        return "\n".join(transcriptions)
+
+    raise RuntimeError("Max polls exceeded, Azure speech did not yield a response")
+
+
+@redis_cache_decorator(ex=settings.REDIS_MODELS_CACHE_EXPIRY)
+def azure_get_latest_model(language: str) -> dict | None:
+    # https://eastus.dev.cognitive.microsoft.com/docs/services/speech-to-text-api-v3-1/operations/Models_ListBaseModels
+    r = requests.get(
+        str(furl(settings.AZURE_SPEECH_ENDPOINT) / "speechtotext/v3.1/models/base"),
+        headers=azure_auth_header(),
+        params={"filter": f"locale eq '{language}'"},
+    )
+    raise_for_status(r)
+    data = r.json()["values"]
+    try:
+        models = sorted(
+            data,
+            key=lambda m: datetime.datetime.strptime(
+                m["createdDateTime"], "%Y-%m-%dT%H:%M:%SZ"
+            ),
+            reverse=True,
+        )
+    # ignore date parsing errors
+    except ValueError:
+        models = data
+        models.reverse()
+    for model in models:
+        if "whisper" in model["displayName"].lower():
+            # whisper is pretty slow on azure, so we ignore it
+            continue
+        # return the latest model
+        return {"self": model["self"]}
+
+
+def azure_auth_header():
+    return {
+        "Ocp-Apim-Subscription-Key": settings.AZURE_SPEECH_KEY,
+    }
diff --git a/daras_ai_v2/azure_doc_extract.py b/daras_ai_v2/azure_doc_extract.py
index b14179dba..878dc5733 100644
--- a/daras_ai_v2/azure_doc_extract.py
+++ b/daras_ai_v2/azure_doc_extract.py
@@ -16,15 +16,17 @@
 auth_headers = {"Ocp-Apim-Subscription-Key": settings.AZURE_FORM_RECOGNIZER_KEY}
 
 
-def azure_doc_extract_pages(pdf_url: str, model_id: str = "prebuilt-layout"):
-    result = azure_form_recognizer(pdf_url, model_id)
+def azure_doc_extract_pages(
+    pdf_url: str, model_id: str = "prebuilt-layout", params: dict = None
+):
+    result = azure_form_recognizer(pdf_url, model_id, params)
     return [
         records_to_text(extract_records(result, page["pageNumber"]))
         for page in result["pages"]
     ]
 
 
-@redis_cache_decorator
+@redis_cache_decorator(ex=settings.REDIS_MODELS_CACHE_EXPIRY)
 def azure_form_recognizer_models() -> dict[str, str]:
     r = requests.get(
         str(
@@ -38,14 +40,14 @@ def azure_form_recognizer_models() -> dict[str, str]:
     return {value["modelId"]: value["description"] for value in r.json()["value"]}
 
 
-@redis_cache_decorator
-def azure_form_recognizer(url: str, model_id: str):
+@redis_cache_decorator(ex=settings.REDIS_MODELS_CACHE_EXPIRY)
+def azure_form_recognizer(url: str, model_id: str, params: dict = None):
     r = requests.post(
         str(
             furl(settings.AZURE_FORM_RECOGNIZER_ENDPOINT)
             / f"formrecognizer/documentModels/{model_id}:analyze"
         ),
-        params={"api-version": "2023-07-31"},
+        params={"api-version": "2023-07-31"} | (params or {}),
         headers=auth_headers,
         json={"urlSource": url},
     )
@@ -67,7 +69,7 @@ def azure_form_recognizer(url: str, model_id: str):
 def extract_records(result: dict, page_num: int) -> list[dict]:
     table_polys = extract_tables(result, page_num)
     records = []
-    for para in result["paragraphs"]:
+    for para in result.get("paragraphs", []):
         try:
             if para["boundingRegions"][0]["pageNumber"] != page_num:
                 continue
diff --git a/daras_ai_v2/azure_image_moderation.py b/daras_ai_v2/azure_image_moderation.py
index 30da7a561..c9afc871a 100644
--- a/daras_ai_v2/azure_image_moderation.py
+++ b/daras_ai_v2/azure_image_moderation.py
@@ -1,7 +1,5 @@
-from typing import Any
-
-from furl import furl
 import requests
+from furl import furl
 
 from daras_ai_v2 import settings
 from daras_ai_v2.exceptions import raise_for_status
@@ -11,7 +9,7 @@ def get_auth_headers():
     return {"Ocp-Apim-Subscription-Key": settings.AZURE_IMAGE_MODERATION_KEY}
 
 
-def run_moderator(image_url: str, cache: bool) -> dict[str, Any]:
+def is_image_nsfw(image_url: str, cache: bool = False) -> bool:
     url = str(
         furl(settings.AZURE_IMAGE_MODERATION_ENDPOINT)
         / "contentmoderator/moderate/v1.0/ProcessImage/Evaluate"
@@ -22,10 +20,9 @@ def run_moderator(image_url: str, cache: bool) -> dict[str, Any]:
         headers=get_auth_headers(),
         json={"DataRepresentation": "URL", "Value": image_url},
     )
+    if r.status_code == 400 and (
+        b"Image Size Error" in r.content or b"Image Error" in r.content
+    ):
+        return False
     raise_for_status(r)
-    return r.json()
-
-
-def is_image_nsfw(image_url: str, cache: bool = False) -> bool:
-    response = run_moderator(image_url=image_url, cache=cache)
-    return response["IsImageAdultClassified"]
+    return r.json().get("IsImageAdultClassified", False)
diff --git a/daras_ai_v2/base.py b/daras_ai_v2/base.py
index b65a65dae..cae24bd49 100644
--- a/daras_ai_v2/base.py
+++ b/daras_ai_v2/base.py
@@ -13,7 +13,6 @@
 from time import sleep
 from types import SimpleNamespace
 
-import requests
 import sentry_sdk
 from django.utils import timezone
 from django.utils.text import slugify
@@ -180,24 +179,52 @@ def get_tab_url(self, tab: str) -> str:
             tab_name=MenuTabs.paths[tab],
         )
 
-    def setup_render(self):
+    def setup_sentry(self, event_processor: typing.Callable = None):
+        def add_user_to_event(event, hint):
+            user = self.request and self.request.user
+            if not user:
+                return event
+            event["user"] = {
+                "id": user.id,
+                "name": user.display_name,
+                "email": user.email,
+                "data": {
+                    field: getattr(user, field)
+                    for field in [
+                        "uid",
+                        "phone_number",
+                        "photo_url",
+                        "balance",
+                        "is_paying",
+                        "is_anonymous",
+                        "is_disabled",
+                        "disable_safety_checker",
+                        "created_at",
+                    ]
+                },
+            }
+            return event
+
         with sentry_sdk.configure_scope() as scope:
             scope.set_extra("base_url", self.app_url())
             scope.set_transaction_name(
                 "/" + self.slug_versions[0], source=TRANSACTION_SOURCE_ROUTE
             )
+            scope.add_event_processor(add_user_to_event)
+            if event_processor:
+                scope.add_event_processor(event_processor)
 
     def refresh_state(self):
         _, run_id, uid = extract_query_params(gooey_get_query_params())
-        channel = f"gooey-outputs/{self.slug_versions[0]}/{uid}/{run_id}"
+        channel = self.realtime_channel_name(run_id, uid)
         output = realtime_pull([channel])[0]
         if output:
             st.session_state.update(output)
 
     def render(self):
-        self.setup_render()
+        self.setup_sentry()
 
-        if self.get_run_state() == RecipeRunState.running:
+        if self.get_run_state(st.session_state) == RecipeRunState.running:
             self.refresh_state()
         else:
             realtime_clear_subs()
@@ -243,7 +270,12 @@ def _render_header(self):
 
                 if tbreadcrumbs:
                     with st.tag("div", className="me-3 mb-1 mb-lg-0 py-2 py-lg-0"):
-                        render_breadcrumbs(tbreadcrumbs)
+                        render_breadcrumbs(
+                            tbreadcrumbs,
+                            is_api_call=(
+                                current_run.is_api_call and self.tab == MenuTabs.run
+                            ),
+                        )
 
                 author = self.run_user or current_run.get_creator()
                 if not is_root_example:
@@ -316,7 +348,7 @@ def _render_social_buttons(self, show_button_text: bool = False):
 
         copy_to_clipboard_button(
             f'<i class="fa-regular fa-link"></i>{button_text}',
-            value=self._get_current_app_url(),
+            value=self.get_tab_url(self.tab),
             type="secondary",
             className="mb-0 ms-lg-2",
         )
@@ -996,9 +1028,7 @@ def get_or_create_root_published_run(cls) -> PublishedRun:
             workflow=cls.workflow,
             published_run_id="",
             defaults={
-                "saved_run": lambda: cls.run_doc_sr(
-                    run_id="", uid="", create=True, parent=None, parent_version=None
-                ),
+                "saved_run": lambda: cls.run_doc_sr(run_id="", uid="", create=True),
                 "created_by": None,
                 "last_edited_by": None,
                 "title": cls.title,
@@ -1022,15 +1052,11 @@ def run_doc_sr(
         run_id: str,
         uid: str,
         create: bool = False,
-        parent: SavedRun | None = None,
-        parent_version: PublishedRunVersion | None = None,
+        defaults: dict = None,
     ) -> SavedRun:
         config = dict(workflow=cls.workflow, uid=uid, run_id=run_id)
         if create:
-            return SavedRun.objects.get_or_create(
-                **config,
-                defaults=dict(parent=parent, parent_version=parent_version),
-            )[0]
+            return SavedRun.objects.get_or_create(**config, defaults=defaults)[0]
         else:
             return SavedRun.objects.get(**config)
 
@@ -1264,7 +1290,9 @@ def _render_report_button(self):
         if not (self.request.user and run_id and uid):
             return
 
-        reported = st.button("❗Report")
+        reported = st.button(
+            '<i class="fa-regular fa-flag"></i> Report', type="tertiary"
+        )
         if not reported:
             return
 
@@ -1306,12 +1334,13 @@ def _render_input_col(self):
             )
         return submitted
 
-    def get_run_state(self) -> RecipeRunState:
-        if st.session_state.get(StateKeys.run_status):
+    @classmethod
+    def get_run_state(cls, state: dict[str, typing.Any]) -> RecipeRunState:
+        if state.get(StateKeys.run_status):
             return RecipeRunState.running
-        elif st.session_state.get(StateKeys.error_msg):
+        elif state.get(StateKeys.error_msg):
             return RecipeRunState.failed
-        elif st.session_state.get(StateKeys.run_time):
+        elif state.get(StateKeys.run_time):
             return RecipeRunState.completed
         else:
             # when user is at a recipe root, and not running anything
@@ -1330,7 +1359,7 @@ def _render_output_col(self, submitted: bool):
 
         self._render_before_output()
 
-        run_state = self.get_run_state()
+        run_state = self.get_run_state(st.session_state)
         match run_state:
             case RecipeRunState.completed:
                 self._render_completed_output()
@@ -1344,12 +1373,11 @@ def _render_output_col(self, submitted: bool):
         # render outputs
         self.render_output()
 
-        if run_state != "waiting":
+        if run_state != RecipeRunState.running:
             self._render_after_output()
 
     def _render_completed_output(self):
-        run_time = st.session_state.get(StateKeys.run_time, 0)
-        st.success(f"Success! Run Time: `{run_time:.2f}` seconds.")
+        pass
 
     def _render_failed_output(self):
         err_msg = st.session_state.get(StateKeys.error_msg)
@@ -1365,12 +1393,10 @@ def render_extra_waiting_output(self):
         if not estimated_run_time:
             return
         if created_at := st.session_state.get("created_at"):
-            if isinstance(created_at, datetime.datetime):
-                start_time = created_at
-            else:
-                start_time = datetime.datetime.fromisoformat(created_at)
+            if isinstance(created_at, str):
+                created_at = datetime.datetime.fromisoformat(created_at)
             with st.countdown_timer(
-                end_time=start_time + datetime.timedelta(seconds=estimated_run_time),
+                end_time=created_at + datetime.timedelta(seconds=estimated_run_time),
                 delay_text="Sorry for the wait. Your run is taking longer than we expected.",
             ):
                 if self.is_current_user_owner() and self.request.user.email:
@@ -1407,7 +1433,7 @@ def should_submit_after_login(self) -> bool:
             and not self.request.user.is_anonymous
         )
 
-    def create_new_run(self):
+    def create_new_run(self, is_api_call: bool = False):
         st.session_state[StateKeys.run_status] = "Starting..."
         st.session_state.pop(StateKeys.error_msg, None)
         st.session_state.pop(StateKeys.run_time, None)
@@ -1442,8 +1468,11 @@ def create_new_run(self):
             run_id,
             uid,
             create=True,
-            parent=parent,
-            parent_version=parent_version,
+            defaults=dict(
+                parent=parent,
+                parent_version=parent_version,
+                is_api_call=is_api_call,
+            ),
         ).set(self.state_to_doc(st.session_state))
 
         return None, run_id, uid
@@ -1457,13 +1486,16 @@ def call_runner_task(self, example_id, run_id, uid, is_api_call=False):
             run_id=run_id,
             uid=uid,
             state=st.session_state,
-            channel=f"gooey-outputs/{self.slug_versions[0]}/{uid}/{run_id}",
+            channel=self.realtime_channel_name(run_id, uid),
             query_params=self.clean_query_params(
                 example_id=example_id, run_id=run_id, uid=uid
             ),
             is_api_call=is_api_call,
         )
 
+    def realtime_channel_name(self, run_id, uid):
+        return f"gooey-outputs/{self.slug_versions[0]}/{uid}/{run_id}"
+
     def generate_credit_error_message(self, example_id, run_id, uid) -> str:
         account_url = furl(settings.APP_BASE_URL) / "account/"
         if self.request.user.is_anonymous:
@@ -1508,22 +1540,17 @@ def clear_outputs(self):
             st.session_state.pop(field_name, None)
 
     def _render_after_output(self):
-        col1, col2, col3 = st.columns([1, 1, 1], responsive=False)
-        col2.node.props[
-            "className"
-        ] += " d-flex justify-content-center align-items-center"
-        col3.node.props["className"] += " d-flex justify-content-end align-items-center"
+        self._render_report_button()
+
         if "seed" in self.RequestModel.schema_json():
-            seed = st.session_state.get("seed")
-            with col1:
-                st.caption(f"*Seed\\\n`{seed}`*")
-            with col2:
-                randomize = st.button("♻️ Regenerate")
-                if randomize:
-                    st.session_state[StateKeys.pressed_randomize] = True
-                    st.experimental_rerun()
-        with col3:
-            self._render_report_button()
+            randomize = st.button(
+                '<i class="fa-solid fa-recycle"></i> Regenerate', type="tertiary"
+            )
+            if randomize:
+                st.session_state[StateKeys.pressed_randomize] = True
+                st.experimental_rerun()
+
+        render_output_caption()
 
     def state_to_doc(self, state: dict):
         ret = {
@@ -1791,8 +1818,8 @@ def run_as_api_tab(self):
         as_async = st.checkbox("##### Run Async")
         as_form_data = st.checkbox("##### Upload Files via Form Data")
 
-        request_body = get_example_request_body(
-            self.RequestModel, st.session_state, include_all=include_all
+        request_body = self.get_example_request_body(
+            st.session_state, include_all=include_all
         )
         response_body = self.get_example_response_body(
             st.session_state, as_async=as_async, include_all=include_all
@@ -1838,7 +1865,27 @@ def get_price_roundoff(self, state: dict) -> int:
         return max(1, math.ceil(self.get_raw_price(state)))
 
     def get_raw_price(self, state: dict) -> float:
-        return self.price
+        return self.price * state.get("num_outputs", 1)
+
+    @classmethod
+    def get_example_preferred_fields(cls, state: dict) -> list[str]:
+        """
+        Fields that are not required, but are preferred to be shown in the example.
+        """
+        return []
+
+    @classmethod
+    def get_example_request_body(
+        cls,
+        state: dict,
+        include_all: bool = False,
+    ) -> dict:
+        return extract_model_fields(
+            cls.RequestModel,
+            state,
+            include_all=include_all,
+            preferred_fields=cls.get_example_preferred_fields(state),
+        )
 
     def get_example_response_body(
         self,
@@ -1854,6 +1901,7 @@ def get_example_response_body(
             run_id=run_id,
             uid=self.request.user and self.request.user.uid,
         )
+        output = extract_model_fields(self.ResponseModel, state, include_all=True)
         if as_async:
             return dict(
                 run_id=run_id,
@@ -1861,18 +1909,14 @@ def get_example_response_body(
                 created_at=created_at,
                 run_time_sec=st.session_state.get(StateKeys.run_time, 0),
                 status="completed",
-                output=get_example_request_body(
-                    self.ResponseModel, state, include_all=include_all
-                ),
+                output=output,
             )
         else:
             return dict(
                 id=run_id,
                 url=web_url,
                 created_at=created_at,
-                output=get_example_request_body(
-                    self.ResponseModel, state, include_all=include_all
-                ),
+                output=output,
             )
 
     def additional_notes(self) -> str | None:
@@ -1900,15 +1944,41 @@ def is_current_user_owner(self) -> bool:
         )
 
 
-def get_example_request_body(
-    request_model: typing.Type[BaseModel],
+def render_output_caption():
+    caption = ""
+
+    run_time = st.session_state.get(StateKeys.run_time, 0)
+    if run_time:
+        caption += f'Generated in <span style="color: black;">{run_time :.2f}s</span>'
+
+    if seed := st.session_state.get("seed"):
+        caption += f' with seed <span style="color: black;">{seed}</span> '
+
+    created_at = st.session_state.get(StateKeys.created_at, datetime.datetime.today())
+    if created_at:
+        if isinstance(created_at, str):
+            created_at = datetime.datetime.fromisoformat(created_at)
+        format_created_at = created_at.strftime(settings.SHORT_DATETIME_FORMAT)
+        caption += f' at <span style="color: black;">{format_created_at}</span>'
+
+    st.caption(caption, unsafe_allow_html=True)
+
+
+def extract_model_fields(
+    model: typing.Type[BaseModel],
     state: dict,
     include_all: bool = False,
+    preferred_fields: list[str] = None,
 ) -> dict:
+    """Only returns required fields unless include_all is set to True."""
     return {
         field_name: state.get(field_name)
-        for field_name, field in request_model.__fields__.items()
-        if include_all or field.required
+        for field_name, field in model.__fields__.items()
+        if (
+            include_all
+            or field.required
+            or (preferred_fields and field_name in preferred_fields)
+        )
     }
 
 
@@ -1928,27 +1998,6 @@ def extract_nested_str(obj) -> str:
     return ""
 
 
-def err_msg_for_exc(e):
-    if isinstance(e, requests.HTTPError):
-        response: requests.Response = e.response
-        try:
-            err_body = response.json()
-        except requests.JSONDecodeError:
-            err_str = response.text
-        else:
-            format_exc = err_body.get("format_exc")
-            if format_exc:
-                print("⚡️ " + format_exc)
-            err_type = err_body.get("type")
-            err_str = err_body.get("str")
-            if err_type and err_str:
-                return f"(GPU) {err_type}: {err_str}"
-            err_str = str(err_body)
-        return f"(HTTP {response.status_code}) {html.escape(err_str[:1000])}"
-    else:
-        return f"{type(e).__name__}: {e}"
-
-
 def force_redirect(url: str):
     # note: assumes sanitized URLs
     st.html(
diff --git a/daras_ai_v2/bot_integration_widgets.py b/daras_ai_v2/bot_integration_widgets.py
index 3880f9fe7..73c6ccad0 100644
--- a/daras_ai_v2/bot_integration_widgets.py
+++ b/daras_ai_v2/bot_integration_widgets.py
@@ -19,11 +19,19 @@ def general_integration_settings(bi: BotIntegration):
         st.session_state[f"_bi_user_language_{bi.id}"] = BotIntegration._meta.get_field(
             "user_language"
         ).default
-        st.session_state[
-            f"_bi_show_feedback_buttons_{bi.id}"
-        ] = BotIntegration._meta.get_field("show_feedback_buttons").default
+        st.session_state[f"_bi_streaming_enabled_{bi.id}"] = (
+            BotIntegration._meta.get_field("streaming_enabled").default
+        )
+        st.session_state[f"_bi_show_feedback_buttons_{bi.id}"] = (
+            BotIntegration._meta.get_field("show_feedback_buttons").default
+        )
         st.session_state[f"_bi_analysis_url_{bi.id}"] = None
 
+    bi.streaming_enabled = st.checkbox(
+        "**📡 Streaming Enabled**",
+        value=bi.streaming_enabled,
+        key=f"_bi_streaming_enabled_{bi.id}",
+    )
     bi.show_feedback_buttons = st.checkbox(
         "**👍🏾 👎🏽 Show Feedback Buttons**",
         value=bi.show_feedback_buttons,
diff --git a/daras_ai_v2/bots.py b/daras_ai_v2/bots.py
index dfc00c794..7075e3b2d 100644
--- a/daras_ai_v2/bots.py
+++ b/daras_ai_v2/bots.py
@@ -1,9 +1,11 @@
 import mimetypes
 import traceback
 import typing
+from datetime import datetime
 from urllib.parse import parse_qs
 
 from django.db import transaction
+from django.utils import timezone
 from fastapi import HTTPException, Request
 from furl import furl
 from sentry_sdk import capture_exception
@@ -20,11 +22,13 @@
     MessageAttachment,
 )
 from daras_ai_v2.asr import AsrModels, run_google_translate
-from daras_ai_v2.base import BasePage
+from daras_ai_v2.base import BasePage, RecipeRunState, StateKeys
 from daras_ai_v2.language_model import CHATML_ROLE_USER, CHATML_ROLE_ASSISTANT
 from daras_ai_v2.vector_search import doc_url_to_file_metadata
-from gooeysite.bg_db_conn import db_middleware
+from gooey_ui.pubsub import realtime_subscribe
+from gooeysite.bg_db_conn import db_middleware, get_celery_result_db_safe
 from recipes.VideoBots import VideoBotsPage, ReplyButton
+from routers.api import submit_api_call
 
 PAGE_NOT_CONNECTED_ERROR = (
     "💔 Looks like you haven't connected this page to a gooey.ai workflow. "
@@ -47,7 +51,7 @@
 """.strip()
 
 ERROR_MSG = """
-`{0!r}`
+`{}`
 
 ⚠️ Sorry, I ran into an error while processing your request. Please try again, or type "Reset" to start over.
 """.strip()
@@ -60,6 +64,8 @@
 
 TAPPED_SKIP_MSG = "🌱 Alright. What else can I help you with?"
 
+SLACK_MAX_SIZE = 3000
+
 
 async def request_json(request: Request):
     return await request.json()
@@ -80,33 +86,13 @@ class BotInterface:
     input_type: str
     language: str
     show_feedback_buttons: bool = False
+    streaming_enabled: bool = False
+    can_update_message: bool = False
     convo: Conversation
     recieved_msg_id: str = None
     input_glossary: str | None = None
     output_glossary: str | None = None
 
-    def send_msg_or_default(
-        self,
-        *,
-        text: str | None = None,
-        audio: str = None,
-        video: str = None,
-        buttons: list[ReplyButton] = None,
-        documents: list[str] = None,
-        should_translate: bool = False,
-        default: str = DEFAULT_RESPONSE,
-    ):
-        if not (text or audio or video or documents):
-            text = default
-        return self.send_msg(
-            text=text,
-            audio=audio,
-            video=video,
-            buttons=buttons,
-            documents=documents,
-            should_translate=should_translate,
-        )
-
     def send_msg(
         self,
         *,
@@ -116,6 +102,7 @@ def send_msg(
         buttons: list[ReplyButton] = None,
         documents: list[str] = None,
         should_translate: bool = False,
+        update_msg_id: str = None,
     ) -> str | None:
         raise NotImplementedError
 
@@ -166,6 +153,7 @@ def _unpack_bot_integration(self):
         self.billing_account_uid = bi.billing_account_uid
         self.language = bi.user_language
         self.show_feedback_buttons = bi.show_feedback_buttons
+        self.streaming_enabled = bi.streaming_enabled
 
     def get_interactive_msg_info(self) -> tuple[str, str]:
         raise NotImplementedError("This bot does not support interactive messages.")
@@ -202,6 +190,7 @@ def _on_msg(bot: BotInterface):
     speech_run = None
     input_images = None
     input_documents = None
+    recieved_time: datetime = timezone.now()
     if not bot.page_cls:
         bot.send_msg(text=PAGE_NOT_CONNECTED_ERROR)
         return
@@ -265,8 +254,8 @@ def _on_msg(bot: BotInterface):
             return
     # handle reset keyword
     if input_text.lower() == RESET_KEYWORD:
-        # clear saved messages
-        bot.convo.messages.all().delete()
+        # record the reset time so we don't send context
+        bot.convo.reset_at = timezone.now()
         # reset convo state
         bot.convo.state = ConvoState.INITIAL
         bot.convo.save()
@@ -286,6 +275,7 @@ def _on_msg(bot: BotInterface):
             input_documents=input_documents,
             input_text=input_text,
             speech_run=speech_run,
+            recieved_time=recieved_time,
         )
 
 
@@ -324,41 +314,115 @@ def _process_and_send_msg(
     input_images: list[str] | None,
     input_documents: list[str] | None,
     input_text: str,
+    recieved_time: datetime,
     speech_run: str | None,
 ):
-    try:
-        # # mock testing
-        # msgs_to_save, response_audio, response_text, response_video = _echo(
-        #     bot, input_text
-        # )
-        # make API call to gooey bots to get the response
-        response, url = _process_msg(
-            page_cls=bot.page_cls,
-            api_user=billing_account_user,
-            query_params=bot.query_params,
-            convo=bot.convo,
-            input_text=input_text,
-            user_language=bot.language,
-            speech_run=speech_run,
-            input_images=input_images,
-            input_documents=input_documents,
-        )
-    except HTTPException as e:
-        traceback.print_exc()
-        capture_exception(e)
-        # send error msg as repsonse
-        bot.send_msg(text=ERROR_MSG.format(e))
-        return
+    # get latest messages for context
+    saved_msgs = bot.convo.messages.all().as_llm_context(reset_at=bot.convo.reset_at)
 
-    # send the response to the user
-    msg_id = bot.send_msg_or_default(
-        text=response.output_text and response.output_text[0],
-        audio=response.output_audio and response.output_audio[0],
-        video=response.output_video and response.output_video[0],
-        documents=response.output_documents or [],
-        buttons=_feedback_start_buttons() if bot.show_feedback_buttons else None,
+    # # mock testing
+    # result = _mock_api_output(input_text)
+    page, result, run_id, uid = submit_api_call(
+        page_cls=bot.page_cls,
+        user=billing_account_user,
+        request_body={
+            "input_prompt": input_text,
+            "input_images": input_images,
+            "input_documents": input_documents,
+            "messages": saved_msgs,
+            "user_language": bot.language,
+        },
+        query_params=bot.query_params,
     )
 
+    if bot.show_feedback_buttons:
+        buttons = _feedback_start_buttons()
+    else:
+        buttons = None
+
+    update_msg_id = None  # this is the message id to update during streaming
+    sent_msg_id = None  # this is the message id to record in the db
+    last_idx = 0  # this is the last index of the text sent to the user
+    if bot.streaming_enabled:
+        # subscribe to the realtime channel for updates
+        channel = page.realtime_channel_name(run_id, uid)
+        with realtime_subscribe(channel) as realtime_gen:
+            for state in realtime_gen:
+                run_state = page.get_run_state(state)
+                run_status = state.get(StateKeys.run_status) or ""
+                # check for errors
+                if run_state == RecipeRunState.failed:
+                    err_msg = state.get(StateKeys.error_msg)
+                    bot.send_msg(text=ERROR_MSG.format(err_msg))
+                    return  # abort
+                if run_state != RecipeRunState.running:
+                    break  # we're done running, abort
+                text = state.get("output_text") and state.get("output_text")[0]
+                if not text:
+                    # if no text, send the run status
+                    if bot.can_update_message:
+                        update_msg_id = bot.send_msg(
+                            text=run_status, update_msg_id=update_msg_id
+                        )
+                    continue  # no text, wait for the next update
+                streaming_done = not run_status.lower().startswith("streaming")
+                # send the response to the user
+                if bot.can_update_message:
+                    update_msg_id = bot.send_msg(
+                        text=text.strip() + "...",
+                        update_msg_id=update_msg_id,
+                        buttons=buttons if streaming_done else None,
+                    )
+                    last_idx = len(text)
+                else:
+                    next_chunk = text[last_idx:]
+                    last_idx = len(text)
+                    if not next_chunk:
+                        continue  # no chunk, wait for the next update
+                    update_msg_id = bot.send_msg(
+                        text=next_chunk,
+                        buttons=buttons if streaming_done else None,
+                    )
+                if streaming_done and not bot.can_update_message:
+                    # if we send the buttons, this is the ID we need to record in the db for lookups later when the button is pressed
+                    sent_msg_id = update_msg_id
+                    # don't show buttons again
+                    buttons = None
+                if streaming_done:
+                    break  # we're done streaming, abort
+
+    # wait for the celery task to finish
+    get_celery_result_db_safe(result)
+    # get the final state from db
+    state = page.run_doc_sr(run_id, uid).to_dict()
+    # check for errors
+    err_msg = state.get(StateKeys.error_msg)
+    if err_msg:
+        bot.send_msg(text=ERROR_MSG.format(err_msg))
+        return
+
+    text = (state.get("output_text") and state.get("output_text")[0]) or ""
+    audio = state.get("output_audio") and state.get("output_audio")[0]
+    video = state.get("output_video") and state.get("output_video")[0]
+    documents = state.get("output_documents") or []
+    # check for empty response
+    if not (text or audio or video or documents or buttons):
+        bot.send_msg(text=DEFAULT_RESPONSE)
+        return
+    # if in-place updates are enabled, update the message, otherwise send the remaining text
+    if not bot.can_update_message:
+        text = text[last_idx:]
+    # send the response to the user if there is any remaining
+    if text or audio or video or documents or buttons:
+        update_msg_id = bot.send_msg(
+            text=text,
+            audio=audio,
+            video=video,
+            documents=documents,
+            buttons=buttons,
+            update_msg_id=update_msg_id,
+        )
+
     # save msgs to db
     _save_msgs(
         bot=bot,
@@ -366,9 +430,10 @@ def _process_and_send_msg(
         input_documents=input_documents,
         input_text=input_text,
         speech_run=speech_run,
-        platform_msg_id=msg_id,
-        response=response,
-        url=url,
+        platform_msg_id=sent_msg_id or update_msg_id,
+        response=VideoBotsPage.ResponseModel.parse_obj(state),
+        url=page.app_url(run_id=run_id, uid=uid),
+        received_time=recieved_time,
     )
 
 
@@ -381,6 +446,7 @@ def _save_msgs(
     platform_msg_id: str | None,
     response: VideoBotsPage.ResponseModel,
     url: str,
+    received_time: datetime,
 ):
     # create messages for future context
     user_msg = Message(
@@ -389,11 +455,14 @@ def _save_msgs(
         role=CHATML_ROLE_USER,
         content=response.raw_input_text,
         display_content=input_text,
-        saved_run=SavedRun.objects.get_or_create(
-            workflow=Workflow.ASR, **furl(speech_run).query.params
-        )[0]
-        if speech_run
-        else None,
+        saved_run=(
+            SavedRun.objects.get_or_create(
+                workflow=Workflow.ASR, **furl(speech_run).query.params
+            )[0]
+            if speech_run
+            else None
+        ),
+        response_time=timezone.now() - received_time,
     )
     attachments = []
     for f_url in (input_images or []) + (input_documents or []):
@@ -410,6 +479,7 @@ def _save_msgs(
         saved_run=SavedRun.objects.get_or_create(
             workflow=Workflow.VIDEO_BOTS, **furl(url).query.params
         )[0],
+        response_time=timezone.now() - received_time,
     )
     # save the messages & attachments
     with transaction.atomic():
@@ -420,45 +490,6 @@ def _save_msgs(
         assistant_msg.save()
 
 
-def _process_msg(
-    *,
-    page_cls,
-    api_user: AppUser,
-    query_params: dict,
-    convo: Conversation,
-    input_images: list[str] | None,
-    input_documents: list[str] | None,
-    input_text: str,
-    user_language: str,
-    speech_run: str | None,
-) -> tuple[VideoBotsPage.ResponseModel, str]:
-    from routers.api import call_api
-
-    # get latest messages for context (upto 100)
-    saved_msgs = convo.messages.all().as_llm_context()
-
-    # # mock testing
-    # result = _mock_api_output(input_text)
-
-    # call the api with provided input
-    result = call_api(
-        page_cls=page_cls,
-        user=api_user,
-        request_body={
-            "input_prompt": input_text,
-            "input_images": input_images,
-            "input_documents": input_documents,
-            "messages": saved_msgs,
-            "user_language": user_language,
-        },
-        query_params=query_params,
-    )
-    # parse result
-    response = page_cls.ResponseModel.parse_obj(result["output"])
-    url = result.get("url", "")
-    return response, url
-
-
 def _handle_interactive_msg(bot: BotInterface):
     try:
         button_id, context_msg_id = bot.get_interactive_msg_info()
@@ -478,13 +509,25 @@ def _handle_interactive_msg(bot: BotInterface):
                 return
             if button_id == ButtonIds.feedback_thumbs_up:
                 rating = Feedback.Rating.RATING_THUMBS_UP
-                bot.convo.state = ConvoState.ASK_FOR_FEEDBACK_THUMBS_UP
-                response_text = FEEDBACK_THUMBS_UP_MSG
+                # bot.convo.state = ConvoState.ASK_FOR_FEEDBACK_THUMBS_UP
+                # response_text = FEEDBACK_THUMBS_UP_MSG
             else:
                 rating = Feedback.Rating.RATING_THUMBS_DOWN
-                bot.convo.state = ConvoState.ASK_FOR_FEEDBACK_THUMBS_DOWN
-                response_text = FEEDBACK_THUMBS_DOWN_MSG
+                # bot.convo.state = ConvoState.ASK_FOR_FEEDBACK_THUMBS_DOWN
+                # response_text = FEEDBACK_THUMBS_DOWN_MSG
+            response_text = FEEDBACK_CONFIRMED_MSG.format(
+                bot_name=str(bot.convo.bot_integration.name)
+            )
             bot.convo.save()
+            # save the feedback
+            Feedback.objects.create(message=context_msg, rating=rating)
+            # send a confirmation msg + post click buttons
+            bot.send_msg(
+                text=response_text,
+                # buttons=_feedback_post_click_buttons(),
+                should_translate=True,
+            )
+
         # handle skip
         case ButtonIds.action_skip:
             bot.send_msg(text=TAPPED_SKIP_MSG, should_translate=True)
@@ -492,6 +535,7 @@ def _handle_interactive_msg(bot: BotInterface):
             bot.convo.state = ConvoState.INITIAL
             bot.convo.save()
             return
+
         # not sure what button was pressed, ignore
         case _:
             bot_name = str(bot.convo.bot_integration.name)
@@ -503,14 +547,6 @@ def _handle_interactive_msg(bot: BotInterface):
             bot.convo.state = ConvoState.INITIAL
             bot.convo.save()
             return
-    # save the feedback
-    Feedback.objects.create(message=context_msg, rating=rating)
-    # send a confirmation msg + post click buttons
-    bot.send_msg(
-        text=response_text,
-        buttons=_feedback_post_click_buttons(),
-        should_translate=True,
-    )
 
 
 def _handle_audio_msg(billing_account_user, bot: BotInterface):
@@ -533,8 +569,12 @@ def _handle_audio_msg(billing_account_user, bot: BotInterface):
             selected_model = AsrModels.whisper_telugu_large_v2.name
         case "bho":
             selected_model = AsrModels.vakyansh_bhojpuri.name
-        case "en":
-            selected_model = AsrModels.usm.name
+        case "sw":
+            selected_model = AsrModels.seamless_m4t.name
+            language = "swh"
+        # case "en":
+        #     selected_model = AsrModels.usm.name
+        #     language = "am-et"
         case _:
             selected_model = AsrModels.whisper_large_v2.name
 
diff --git a/daras_ai_v2/breadcrumbs.py b/daras_ai_v2/breadcrumbs.py
index 96dc919e5..94e63cb80 100644
--- a/daras_ai_v2/breadcrumbs.py
+++ b/daras_ai_v2/breadcrumbs.py
@@ -31,7 +31,7 @@ def has_breadcrumbs(self):
         return bool(self.root_title or self.published_title)
 
 
-def render_breadcrumbs(breadcrumbs: TitleBreadCrumbs):
+def render_breadcrumbs(breadcrumbs: TitleBreadCrumbs, *, is_api_call: bool = False):
     st.html(
         """
         <style>
@@ -68,6 +68,9 @@ def render_breadcrumbs(breadcrumbs: TitleBreadCrumbs):
                 link_to=breadcrumbs.published_title.url,
             )
 
+        if is_api_call:
+            st.caption("(API)")
+
 
 def get_title_breadcrumbs(
     page_cls: typing.Union["BasePage", typing.Type["BasePage"]],
@@ -89,12 +92,21 @@ def get_title_breadcrumbs(
     root_breadcrumb = TitleUrl(metadata.short_title, page_cls.app_url())
 
     match tab:
-        case MenuTabs.examples:
+        case MenuTabs.examples | MenuTabs.history | MenuTabs.saved:
+            label = MenuTabs.display_labels[tab]
             return TitleBreadCrumbs(
-                f"Examples: {metadata.short_title}",
+                f"{label}: {metadata.short_title}",
                 root_title=root_breadcrumb,
                 published_title=None,
             )
+        case MenuTabs.run_as_api | MenuTabs.integrations:
+            label = MenuTabs.display_labels[tab]
+            tbreadcrumbs_on_run = get_title_breadcrumbs(page_cls=page_cls, sr=sr, pr=pr)
+            return TitleBreadCrumbs(
+                f"{label}: {tbreadcrumbs_on_run.h1_title}",
+                root_title=tbreadcrumbs_on_run.root_title or root_breadcrumb,
+                published_title=tbreadcrumbs_on_run.published_title,
+            )
         case _ if is_root:
             return TitleBreadCrumbs(page_cls.get_recipe_title(), None, None)
         case _ if is_example:
@@ -118,4 +130,4 @@ def get_title_breadcrumbs(
                 published_title=published_title,
             )
         case _:
-            raise AssertionError("Invalid tab or run")
+            raise ValueError(f"Unknown tab: {tab}")
diff --git a/daras_ai_v2/crypto.py b/daras_ai_v2/crypto.py
index 30bef7f4f..ec0047bbd 100644
--- a/daras_ai_v2/crypto.py
+++ b/daras_ai_v2/crypto.py
@@ -65,7 +65,7 @@ def safe_preview(password: str) -> str:
 
 def get_random_doc_id() -> str:
     return get_random_string(
-        length=8, allowed_chars=string.ascii_lowercase + string.digits
+        length=12, allowed_chars=string.ascii_lowercase + string.digits
     )
 
 
diff --git a/daras_ai_v2/db.py b/daras_ai_v2/db.py
index a4d4c287f..ffb10bd18 100644
--- a/daras_ai_v2/db.py
+++ b/daras_ai_v2/db.py
@@ -1,3 +1,9 @@
+import typing
+
+if typing.TYPE_CHECKING:
+    from google.cloud import firestore
+
+
 FIREBASE_SESSION_COOKIE = "firebase_session"
 ANONYMOUS_USER_COOKIE = "anonymous_user"
 
diff --git a/daras_ai_v2/doc_search_settings_widgets.py b/daras_ai_v2/doc_search_settings_widgets.py
index bdeae11e6..4c0464475 100644
--- a/daras_ai_v2/doc_search_settings_widgets.py
+++ b/daras_ai_v2/doc_search_settings_widgets.py
@@ -1,11 +1,15 @@
 import os
 import typing
 
+from furl import furl
+from sentry_sdk import capture_exception
+
 import gooey_ui as st
 from daras_ai_v2 import settings
 from daras_ai_v2.asr import AsrModels, google_translate_language_selector
 from daras_ai_v2.prompt_vars import prompt_vars_widget
 from daras_ai_v2.enum_selector_widget import enum_selector
+from daras_ai_v2.gdrive_downloader import gdrive_list_urls_of_files_in_folder
 from daras_ai_v2.search_ref import CitationStyles
 
 _user_media_url_prefix = os.path.join(
@@ -37,11 +41,8 @@ def document_uploader(
     documents = st.session_state.get(key) or []
     if isinstance(documents, str):
         documents = [documents]
-    has_custom_urls = not all(map(is_user_uploaded_url, documents))
     custom_key = "__custom_" + key
-    if st.checkbox(
-        "Enter Custom URLs", key=f"__custom_checkbox_{key}", value=has_custom_urls
-    ):
+    if st.session_state.get(f"__custom_checkbox_{key}"):
         if not custom_key in st.session_state:
             st.session_state[custom_key] = "\n".join(documents)
         if accept_multiple_files:
@@ -64,7 +65,7 @@ def document_uploader(
             **kwargs,
         )
         if accept_multiple_files:
-            st.session_state[key] = text_value.strip().splitlines()
+            st.session_state[key] = filter(None, text_value.strip().splitlines())
         else:
             st.session_state[key] = text_value
     else:
@@ -76,7 +77,25 @@ def document_uploader(
             accept=accept,
             accept_multiple_files=accept_multiple_files,
         )
-    return st.session_state.get(key, [])
+    st.checkbox("Submit Links in Bulk", key=f"__custom_checkbox_{key}")
+    documents = st.session_state.get(key, [])
+    if accept_multiple_files:
+        try:
+            documents = list(_expand_gdrive_folders(documents))
+        except Exception as e:
+            capture_exception(e)
+            st.error(f"Error expanding gdrive folders: {e}")
+    st.session_state[key] = documents
+    st.session_state[custom_key] = "\n".join(documents)
+    return documents
+
+
+def _expand_gdrive_folders(documents: list[str]) -> list[str]:
+    for url in documents:
+        if url.startswith("https://drive.google.com/drive/folders"):
+            yield from gdrive_list_urls_of_files_in_folder(furl(url))
+        else:
+            yield url
 
 
 def doc_search_settings(
diff --git a/daras_ai_v2/exceptions.py b/daras_ai_v2/exceptions.py
index 5d58145a4..e97ac7190 100644
--- a/daras_ai_v2/exceptions.py
+++ b/daras_ai_v2/exceptions.py
@@ -1,11 +1,9 @@
-from logging import getLogger
+import json
+import subprocess
 
 import requests
+from loguru import logger
 from requests import HTTPError
-from requests.exceptions import JSONDecodeError
-
-
-logger = getLogger(__name__)
 
 
 def raise_for_status(resp: requests.Response):
@@ -24,20 +22,65 @@ def raise_for_status(resp: requests.Response):
     else:
         reason = resp.reason
 
-    try:
-        response_body = str(resp.json())
-    except JSONDecodeError:
-        try:
-            response_body = resp.text
-        except ValueError:
-            response_body = resp.content
-    response_body = response_body[:500]  # truncate to at max 500 characters
-
     if 400 <= resp.status_code < 500:
-        http_error_msg = f"{resp.status_code} Client Error: {reason} | URL: {resp.url} | Response: {response_body!r}"
+        http_error_msg = f"{resp.status_code} Client Error: {reason} | URL: {resp.url} | Response: {_response_preview(resp)!r}"
 
     elif 500 <= resp.status_code < 600:
-        http_error_msg = f"{resp.status_code} Server Error: {reason} | URL: {resp.url} | Response: {response_body!r}"
+        http_error_msg = f"{resp.status_code} Server Error: {reason} | URL: {resp.url} | Response: {_response_preview(resp)!r}"
 
     if http_error_msg:
         raise HTTPError(http_error_msg, response=resp)
+
+
+def _response_preview(resp: requests.Response) -> bytes:
+    from daras_ai.image_input import truncate_filename
+
+    return truncate_filename(resp.content, 500, sep=b"...")
+
+
+class UserError(Exception):
+    def __init__(self, message: str, sentry_level: str = "info"):
+        self.message = message
+        self.sentry_level = sentry_level
+        super().__init__(message)
+
+
+class GPUError(UserError):
+    pass
+
+
+FFMPEG_ERR_MSG = (
+    "Unsupported File Format\n\n"
+    "We encountered an issue processing your file as it appears to be in a format not supported by our system or may be corrupted. "
+    "You can find a list of supported formats at [FFmpeg Formats](https://ffmpeg.org/general.html#File-Formats)."
+)
+
+
+def ffmpeg(*args) -> str:
+    return call_cmd("ffmpeg", "-hide_banner", "-y", *args, err_msg=FFMPEG_ERR_MSG)
+
+
+def ffprobe(filename: str) -> dict:
+    text = call_cmd(
+        "ffprobe",
+        "-v",
+        "quiet",
+        "-print_format",
+        "json",
+        "-show_streams",
+        filename,
+        err_msg=FFMPEG_ERR_MSG,
+    )
+    return json.loads(text)
+
+
+def call_cmd(*args, err_msg: str = "") -> str:
+    logger.info("$ " + " ".join(map(str, args)))
+    try:
+        return subprocess.check_output(args, stderr=subprocess.STDOUT, text=True)
+    except subprocess.CalledProcessError as e:
+        err_msg = err_msg or f"{str(args[0]).capitalize()} Error"
+        try:
+            raise subprocess.SubprocessError(e.output) from e
+        except subprocess.SubprocessError as e:
+            raise UserError(err_msg) from e
diff --git a/daras_ai_v2/facebook_bots.py b/daras_ai_v2/facebook_bots.py
index 2a22bbddd..abf33b8a0 100644
--- a/daras_ai_v2/facebook_bots.py
+++ b/daras_ai_v2/facebook_bots.py
@@ -102,12 +102,12 @@ def send_msg(
         buttons: list[ReplyButton] = None,
         documents: list[str] = None,
         should_translate: bool = False,
+        update_msg_id: str = None,
     ) -> str | None:
         if text and should_translate and self.language and self.language != "en":
             text = run_google_translate(
                 [text], self.language, glossary_url=self.output_glossary
             )[0]
-        text = text or "\u200b"  # handle empty text with zero-width space
         return self.send_msg_to(
             bot_number=self.bot_id,
             user_number=self.user_id,
@@ -123,9 +123,9 @@ def mark_read(self):
 
     @classmethod
     def send_msg_to(
-        self,
+        cls,
         *,
-        text: str,
+        text: str = None,
         audio: str = None,
         video: str = None,
         documents: list[str] = None,
@@ -137,7 +137,7 @@ def send_msg_to(
         # see https://developers.facebook.com/docs/whatsapp/api/messages/media/
 
         # split text into chunks if too long
-        if len(text) > WA_MSG_MAX_SIZE:
+        if text and len(text) > WA_MSG_MAX_SIZE:
             splits = text_splitter(
                 text, chunk_size=WA_MSG_MAX_SIZE, length_function=len
             )
@@ -160,6 +160,7 @@ def send_msg_to(
                 ],
             )
 
+        messages = []
         if video:
             if buttons:
                 messages = [
@@ -168,7 +169,7 @@ def send_msg_to(
                         buttons,
                         {
                             "body": {
-                                "text": text,
+                                "text": text or "\u200b",
                             },
                             "header": {
                                 "type": "video",
@@ -188,74 +189,38 @@ def send_msg_to(
                         },
                     },
                 ]
-        elif audio:
-            if buttons:
-                # audio can't be sent as an interaction, so send text and audio separately
-                messages = [
-                    # simple audio msg
+        elif buttons:
+            # interactive text msg
+            messages = [
+                _build_msg_buttons(
+                    buttons,
                     {
-                        "type": "audio",
-                        "audio": {"link": audio},
+                        "body": {
+                            "text": text or "\u200b",
+                        }
                     },
-                ]
-                send_wa_msgs_raw(
-                    bot_number=bot_number,
-                    user_number=user_number,
-                    messages=messages,
-                )
-                messages = [
-                    # interactive text msg
-                    _build_msg_buttons(
-                        buttons,
-                        {
-                            "body": {
-                                "text": text,
-                            },
-                        },
-                    )
-                ]
-            else:
-                # audio doesn't support captions, so send text and audio separately
-                messages = [
-                    # simple text msg
-                    {
-                        "type": "text",
-                        "text": {
-                            "body": text,
-                            "preview_url": True,
-                        },
-                    },
-                    # simple audio msg
-                    {
-                        "type": "audio",
-                        "audio": {"link": audio},
-                    },
-                ]
-        else:
-            # text message
-            if buttons:
-                messages = [
-                    # interactive text msg
-                    _build_msg_buttons(
-                        buttons,
-                        {
-                            "body": {
-                                "text": text,
-                            }
-                        },
-                    ),
-                ]
-            else:
-                messages = [
-                    # simple text msg
-                    {
-                        "type": "text",
-                        "text": {
-                            "body": text,
-                            "preview_url": True,
-                        },
+                ),
+            ]
+        elif text:
+            # simple text msg
+            messages = [
+                {
+                    "type": "text",
+                    "text": {
+                        "body": text,
+                        "preview_url": True,
                     },
-                ]
+                },
+            ]
+
+        if audio and not video:  # video already has audio
+            # simple audio msg
+            messages.append(
+                {
+                    "type": "audio",
+                    "audio": {"link": audio},
+                }
+            )
 
         if documents:
             messages += [
@@ -398,6 +363,7 @@ def send_msg(
         buttons: list[ReplyButton] = None,
         documents: list[str] = None,
         should_translate: bool = False,
+        update_msg_id: str = None,
     ) -> str | None:
         if text and should_translate and self.language and self.language != "en":
             text = run_google_translate(
diff --git a/daras_ai_v2/gdrive_downloader.py b/daras_ai_v2/gdrive_downloader.py
index 89bcadb5b..5ae9fa176 100644
--- a/daras_ai_v2/gdrive_downloader.py
+++ b/daras_ai_v2/gdrive_downloader.py
@@ -5,6 +5,8 @@
 from googleapiclient import discovery
 from googleapiclient.http import MediaIoBaseDownload
 
+from daras_ai_v2.functional import flatmap_parallel
+
 
 def is_gdrive_url(f: furl) -> bool:
     return f.host in ["drive.google.com", "docs.google.com"]
@@ -25,6 +27,35 @@ def url_to_gdrive_file_id(f: furl) -> str:
     return file_id
 
 
+def gdrive_list_urls_of_files_in_folder(f: furl, max_depth: int = 4) -> list[str]:
+    if max_depth <= 0:
+        return []
+    assert f.host == "drive.google.com", f"Bad google drive folder url: {f}"
+    # get drive folder id from url (e.g. https://drive.google.com/drive/folders/1Xijcsj7oBvDn1OWx4UmNAT8POVKG4W73?usp=drive_link)
+    folder_id = f.path.segments[-1]
+    service = discovery.build("drive", "v3")
+    request = service.files().list(
+        supportsAllDrives=True,
+        includeItemsFromAllDrives=True,
+        q=f"'{folder_id}' in parents",
+        fields="files(mimeType,webViewLink)",
+    )
+    response = request.execute()
+    files = response.get("files", [])
+    urls = flatmap_parallel(
+        lambda file: (
+            gdrive_list_urls_of_files_in_folder(furl(url), max_depth=max_depth - 1)
+            if (
+                (url := file.get("webViewLink"))
+                and file.get("mimeType") == "application/vnd.google-apps.folder"
+            )
+            else [url]
+        ),
+        files,
+    )
+    return filter(None, urls)
+
+
 def gdrive_download(f: furl, mime_type: str) -> tuple[bytes, str]:
     # get drive file id
     file_id = url_to_gdrive_file_id(f)
diff --git a/daras_ai_v2/glossary.py b/daras_ai_v2/glossary.py
index 2e56352da..5444135c1 100644
--- a/daras_ai_v2/glossary.py
+++ b/daras_ai_v2/glossary.py
@@ -1,4 +1,4 @@
-from daras_ai_v2.asr import google_translate_languages
+from daras_ai_v2.asr import google_translate_target_languages
 
 from daras_ai_v2.doc_search_settings_widgets import document_uploader
 
@@ -125,7 +125,8 @@ def get_langcodes_from_df(df: "pd.DataFrame") -> list[str]:
     import langcodes
 
     supported = {
-        langcodes.Language.get(code).language for code in google_translate_languages()
+        langcodes.Language.get(code).language
+        for code in google_translate_target_languages()
     }
     ret = []
     for col in df.columns:
diff --git a/daras_ai_v2/google_asr.py b/daras_ai_v2/google_asr.py
new file mode 100644
index 000000000..222205f6e
--- /dev/null
+++ b/daras_ai_v2/google_asr.py
@@ -0,0 +1,25 @@
+from daras_ai.image_input import gs_url_to_uri
+
+
+def gcp_asr_v1(audio_url: str, language: str) -> str:
+    from google.cloud import speech
+
+    client = speech.SpeechClient()
+    audio = speech.RecognitionAudio(uri=gs_url_to_uri(audio_url))
+    config = speech.RecognitionConfig(
+        encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16,
+        sample_rate_hertz=16000,
+        audio_channel_count=1,
+        language_code=language,
+        model="default",
+    )
+    # Make the request
+    operation = client.long_running_recognize(config=config, audio=audio)
+    # Wait for operation to complete
+    response = operation.result(timeout=600)
+    print(response)
+    return "\n\n".join(
+        result.alternatives[0].transcript
+        for result in response.results
+        if result.alternatives
+    )
diff --git a/daras_ai_v2/gpu_server.py b/daras_ai_v2/gpu_server.py
index fa638da89..33b6ad935 100644
--- a/daras_ai_v2/gpu_server.py
+++ b/daras_ai_v2/gpu_server.py
@@ -2,13 +2,15 @@
 import datetime
 import os
 import typing
+from time import time
 
 import requests
 from furl import furl
 
 from daras_ai.image_input import storage_blob_for
 from daras_ai_v2 import settings
-from daras_ai_v2.exceptions import raise_for_status
+from daras_ai_v2.exceptions import raise_for_status, GPUError
+from gooeysite.bg_db_conn import get_celery_result_db_safe
 
 
 class GpuEndpoints:
@@ -138,6 +140,7 @@ def get_celery():
         _app = Celery()
         _app.conf.broker_url = settings.GPU_CELERY_BROKER_URL
         _app.conf.result_backend = settings.GPU_CELERY_RESULT_BACKEND
+        _app.conf.result_extended = True
 
     return _app
 
@@ -149,8 +152,24 @@ def call_celery_task(
     inputs: dict,
     queue_prefix: str = "gooey-gpu",
 ):
-    queue = os.path.join(queue_prefix, pipeline["model_id"].strip()).strip("/")
+    from usage_costs.cost_utils import record_cost_auto
+    from usage_costs.models import ModelSku
+
+    queue = build_queue_name(queue_prefix, pipeline["model_id"])
     result = get_celery().send_task(
         task_name, kwargs=dict(pipeline=pipeline, inputs=inputs), queue=queue
     )
-    return result.get(disable_sync_subtasks=False)
+    s = time()
+    ret = get_celery_result_db_safe(result, propagate=False)
+    try:
+        result.maybe_throw()
+    except Exception as e:
+        raise GPUError(f"Error in GPU Task {queue}:{task_name} - {e}") from e
+    record_cost_auto(
+        model=queue, sku=ModelSku.gpu_ms, quantity=int((time() - s) * 1000)
+    )
+    return ret
+
+
+def build_queue_name(queue_prefix: str, model_id: str) -> str:
+    return os.path.join(queue_prefix, model_id.strip()).strip("/")
diff --git a/daras_ai_v2/img_model_settings_widgets.py b/daras_ai_v2/img_model_settings_widgets.py
index e86c18873..8249833a0 100644
--- a/daras_ai_v2/img_model_settings_widgets.py
+++ b/daras_ai_v2/img_model_settings_widgets.py
@@ -83,7 +83,7 @@ def model_selector(
         selected_model = enum_selector(
             models_enum,
             label="""
-            ### 🤖 Choose your preferred AI Model
+            #### 🤖 Choose your preferred AI Model
             """,
             key="selected_model",
             use_selectbox=True,
diff --git a/daras_ai_v2/language_model.py b/daras_ai_v2/language_model.py
index 99452a193..fd6142758 100644
--- a/daras_ai_v2/language_model.py
+++ b/daras_ai_v2/language_model.py
@@ -4,7 +4,7 @@
 import re
 import typing
 from enum import Enum
-from functools import partial
+from functools import partial, wraps
 
 import numpy as np
 import requests
@@ -112,11 +112,11 @@ def is_chat_model(self) -> bool:
     LargeLanguageModels.gpt_4_32k: "openai-gpt-4-32k-prod-ca-1",
     LargeLanguageModels.gpt_3_5_turbo: (
         "openai-gpt-35-turbo-prod-ca-1",
-        "gpt-3.5-turbo",
+        "gpt-3.5-turbo-0613",
     ),
     LargeLanguageModels.gpt_3_5_turbo_16k: (
         "openai-gpt-35-turbo-16k-prod-ca-1",
-        "gpt-3.5-turbo-16k",
+        "gpt-3.5-turbo-16k-0613",
     ),
     LargeLanguageModels.text_davinci_003: "text-davinci-003",
     LargeLanguageModels.text_davinci_002: "text-davinci-002",
@@ -208,12 +208,14 @@ def calc_gpt_tokens(
         for entry in messages
         if (
             content := (
-                format_chatml_message(entry) + "\n"
-                if is_chat_model
-                else entry.get("content", "")
+                (
+                    format_chatml_message(entry) + "\n"
+                    if is_chat_model
+                    else entry.get("content", "")
+                )
+                if isinstance(entry, dict)
+                else str(entry)
             )
-            if isinstance(entry, dict)
-            else str(entry)
         )
     )
     return default_length_function(combined)
@@ -340,7 +342,7 @@ def run_language_model(
 ) -> (
     list[str]
     | tuple[list[str], list[list[dict]]]
-    | typing.Generator[list[str], None, None]
+    | typing.Generator[list[dict], None, None]
 ):
     assert bool(prompt) != bool(
         messages
@@ -375,8 +377,9 @@ def run_language_model(
             # we can't stream with tools or json yet
             stream=stream and not (tools or response_format_type),
         )
+
         if stream:
-            return _stream_llm_outputs(entries, is_chatml, response_format_type, tools)
+            return _stream_llm_outputs(entries, response_format_type)
         else:
             return _parse_entries(entries, is_chatml, response_format_type, tools)
     else:
@@ -396,15 +399,28 @@ def run_language_model(
         )
         ret = [msg.strip() for msg in msgs]
         if stream:
-            ret = [ret]
+            ret = [
+                [
+                    format_chat_entry(role=CHATML_ROLE_ASSISTANT, content=msg)
+                    for msg in ret
+                ]
+            ]
         return ret
 
 
-def _stream_llm_outputs(result, is_chatml, response_format_type, tools):
+def _stream_llm_outputs(
+    result: list | typing.Generator[list[ConversationEntry], None, None],
+    response_format_type: typing.Literal["text", "json_object"] | None,
+):
     if isinstance(result, list):  # compatibility with non-streaming apis
         result = [result]
     for entries in result:
-        yield _parse_entries(entries, is_chatml, response_format_type, tools)
+        if response_format_type == "json_object":
+            for i, entry in enumerate(entries):
+                entries[i] = json.loads(entry["content"])
+        for i, entry in enumerate(entries):
+            entries[i]["content"] = entry.get("content") or ""
+        yield entries
 
 
 def _parse_entries(
@@ -544,10 +560,9 @@ def _run_openai_chat(
         presence_penalty = 0
     if isinstance(model, str):
         model = [model]
-    r = try_all(
+    r, used_model = try_all(
         *[
-            partial(
-                _get_openai_client(model_str).chat.completions.create,
+            _get_chat_completions_create(
                 model=model_str,
                 messages=messages,
                 max_tokens=max_tokens,
@@ -557,43 +572,64 @@ def _run_openai_chat(
                 frequency_penalty=frequency_penalty,
                 presence_penalty=presence_penalty,
                 tools=[tool.spec for tool in tools] if tools else NOT_GIVEN,
-                response_format={"type": response_format_type}
-                if response_format_type
-                else NOT_GIVEN,
+                response_format=(
+                    {"type": response_format_type}
+                    if response_format_type
+                    else NOT_GIVEN
+                ),
                 stream=stream,
             )
             for model_str in model
         ],
     )
     if stream:
-        return _stream_openai_chunked(r)
+        return _stream_openai_chunked(r, used_model, messages)
     else:
-        return [choice.message.dict() for choice in r.choices]
+        ret = [choice.message.dict() for choice in r.choices]
+        record_openai_llm_usage(used_model, messages, ret)
+        return ret
+
+
+def _get_chat_completions_create(model: str, **kwargs):
+    client = _get_openai_client(model)
+
+    @wraps(client.chat.completions.create)
+    def wrapper():
+        return client.chat.completions.create(model=model, **kwargs), model
+
+    return wrapper
 
 
 def _stream_openai_chunked(
     r: Stream[ChatCompletionChunk],
+    used_model: str,
+    messages: list[ConversationEntry],
+    *,
     start_chunk_size: int = 50,
     stop_chunk_size: int = 400,
     step_chunk_size: int = 150,
-):
+) -> typing.Generator[list[ConversationEntry], None, None]:
     ret = []
     chunk_size = start_chunk_size
 
     for completion_chunk in r:
         changed = False
         for choice in completion_chunk.choices:
+            delta = choice.delta
             try:
+                # get the entry for this choice
                 entry = ret[choice.index]
             except IndexError:
                 # initialize the entry
-                entry = choice.delta.dict() | {"content": "", "chunk": ""}
+                entry = delta.dict() | {"content": "", "chunk": ""}
                 ret.append(entry)
+            # this is to mark the end of streaming
+            entry["finish_reason"] = choice.finish_reason
 
             # append the delta to the current chunk
-            if not choice.delta.content:
+            if not delta.content:
                 continue
-            entry["chunk"] += choice.delta.content
+            entry["chunk"] += delta.content
             # if the chunk is too small, we need to wait for more data
             chunk = entry["chunk"]
             if len(chunk) < chunk_size:
@@ -627,6 +663,28 @@ def _stream_openai_chunked(
         entry["content"] += entry["chunk"]
     yield ret
 
+    record_openai_llm_usage(used_model, messages, ret)
+
+
+def record_openai_llm_usage(
+    used_model: str, messages: list[ConversationEntry], choices: list[ConversationEntry]
+):
+    from usage_costs.cost_utils import record_cost_auto
+    from usage_costs.models import ModelSku
+
+    record_cost_auto(
+        model=used_model,
+        sku=ModelSku.llm_prompt,
+        quantity=sum(
+            default_length_function(get_entry_text(entry)) for entry in messages
+        ),
+    )
+    record_cost_auto(
+        model=used_model,
+        sku=ModelSku.llm_completion,
+        quantity=sum(default_length_function(entry["content"]) for entry in choices),
+    )
+
 
 @retry_if(openai_should_retry)
 def _run_openai_text(
@@ -650,6 +708,21 @@ def _run_openai_text(
         frequency_penalty=0.1 if avoid_repetition else 0,
         presence_penalty=0.25 if avoid_repetition else 0,
     )
+
+    from usage_costs.cost_utils import record_cost_auto
+    from usage_costs.models import ModelSku
+
+    record_cost_auto(
+        model=model,
+        sku=ModelSku.llm_prompt,
+        quantity=r.usage.prompt_tokens,
+    )
+    record_cost_auto(
+        model=model,
+        sku=ModelSku.llm_completion,
+        quantity=r.usage.completion_tokens,
+    )
+
     return [choice.text for choice in r.choices]
 
 
@@ -707,6 +780,8 @@ def _run_together_chat(
         range(num_outputs),
     )
     ret = []
+    prompt_tokens = 0
+    completion_tokens = 0
     for r in results:
         raise_for_status(r)
         data = r.json()
@@ -720,6 +795,21 @@ def _run_together_chat(
                 "content": output["choices"][0]["text"],
             }
         )
+        prompt_tokens += output.get("usage", {}).get("prompt_tokens", 0)
+        completion_tokens += output.get("usage", {}).get("completion_tokens", 0)
+    from usage_costs.cost_utils import record_cost_auto
+    from usage_costs.models import ModelSku
+
+    record_cost_auto(
+        model=model,
+        sku=ModelSku.llm_prompt,
+        quantity=prompt_tokens,
+    )
+    record_cost_auto(
+        model=model,
+        sku=ModelSku.llm_completion,
+        quantity=completion_tokens,
+    )
     return ret
 
 
@@ -770,13 +860,28 @@ def _run_palm_chat(
         },
     )
     raise_for_status(r)
+    out = r.json()
+
+    from usage_costs.cost_utils import record_cost_auto
+    from usage_costs.models import ModelSku
+
+    record_cost_auto(
+        model=model_id,
+        sku=ModelSku.llm_prompt,
+        quantity=out["metadata"]["tokenMetadata"]["inputTokenCount"]["totalTokens"],
+    )
+    record_cost_auto(
+        model=model_id,
+        sku=ModelSku.llm_completion,
+        quantity=out["metadata"]["tokenMetadata"]["outputTokenCount"]["totalTokens"],
+    )
 
     return [
         {
             "role": msg["author"],
             "content": msg["content"],
         }
-        for pred in r.json()["predictions"]
+        for pred in out["predictions"]
         for msg in pred["candidates"]
     ]
 
@@ -815,7 +920,23 @@ def _run_palm_text(
         },
     )
     raise_for_status(res)
-    return [prediction["content"] for prediction in res.json()["predictions"]]
+    out = res.json()
+
+    from usage_costs.cost_utils import record_cost_auto
+    from usage_costs.models import ModelSku
+
+    record_cost_auto(
+        model=model_id,
+        sku=ModelSku.llm_prompt,
+        quantity=out["metadata"]["tokenMetadata"]["inputTokenCount"]["totalTokens"],
+    )
+    record_cost_auto(
+        model=model_id,
+        sku=ModelSku.llm_completion,
+        quantity=out["metadata"]["tokenMetadata"]["outputTokenCount"]["totalTokens"],
+    )
+
+    return [prediction["content"] for prediction in out["predictions"]]
 
 
 def format_chatml_message(entry: ConversationEntry) -> str:
diff --git a/daras_ai_v2/language_model_settings_widgets.py b/daras_ai_v2/language_model_settings_widgets.py
index 39beee991..0990ed793 100644
--- a/daras_ai_v2/language_model_settings_widgets.py
+++ b/daras_ai_v2/language_model_settings_widgets.py
@@ -38,9 +38,9 @@ def language_model_settings(
                 f"###### {field_title_desc(VideoBotsPage.RequestModel, 'document_model')}",
                 key="document_model",
                 options=[None, *doc_model_descriptions],
-                format_func=lambda x: f"{doc_model_descriptions[x]} ({x})"
-                if x
-                else "———",
+                format_func=lambda x: (
+                    f"{doc_model_descriptions[x]} ({x})" if x else "———"
+                ),
             )
 
     st.checkbox("Avoid Repetition", key="avoid_repetition")
diff --git a/daras_ai_v2/lipsync_api.py b/daras_ai_v2/lipsync_api.py
index 2f4e6e7cc..f8d7a879b 100644
--- a/daras_ai_v2/lipsync_api.py
+++ b/daras_ai_v2/lipsync_api.py
@@ -1,21 +1,27 @@
+from daras_ai_v2.exceptions import UserError
 from daras_ai_v2.gpu_server import call_celery_task_outfile
 
 
 def wav2lip(*, face: str, audio: str, pads: (int, int, int, int)) -> bytes:
-    return call_celery_task_outfile(
-        "wav2lip",
-        pipeline=dict(
-            model_id="wav2lip_gan.pth",
-        ),
-        inputs=dict(
-            face=face,
-            audio=audio,
-            pads=pads,
-            batch_size=256,
-            # "out_height": 480,
-            # "smooth": True,
-            # "fps": 25,
-        ),
-        content_type="video/mp4",
-        filename=f"gooey.ai lipsync.mp4",
-    )[0]
+    try:
+        return call_celery_task_outfile(
+            "wav2lip",
+            pipeline=dict(
+                model_id="wav2lip_gan.pth",
+            ),
+            inputs=dict(
+                face=face,
+                audio=audio,
+                pads=pads,
+                batch_size=256,
+                # "out_height": 480,
+                # "smooth": True,
+                # "fps": 25,
+            ),
+            content_type="video/mp4",
+            filename=f"gooey.ai lipsync.mp4",
+        )[0]
+    except ValueError as e:
+        msg = "\n\n".join(e.args).lower()
+        if "unsupported" in msg:
+            raise UserError(msg) from e
diff --git a/daras_ai_v2/meta_content.py b/daras_ai_v2/meta_content.py
index c7ccc2e18..4bdab3f74 100644
--- a/daras_ai_v2/meta_content.py
+++ b/daras_ai_v2/meta_content.py
@@ -113,7 +113,14 @@ def meta_title_for_page(
 ) -> str:
     match tab:
         case MenuTabs.examples:
-            ret = f"Examples: {metadata.meta_title}"
+            label = MenuTabs.display_labels[tab]
+            ret = f"{label}: {metadata.meta_title}"
+        case MenuTabs.run_as_api | MenuTabs.integrations:
+            label = MenuTabs.display_labels[tab]
+            return f"{label} for {meta_title_for_page(page=page, metadata=metadata, sr=sr, pr=pr, tab=MenuTabs.run)}"
+        case MenuTabs.history | MenuTabs.saved:
+            label = MenuTabs.display_labels[tab]
+            ret = f"{label} for {metadata.short_title}"
         case _ if pr and pr.saved_run == sr and pr.is_root():
             # for root page
             ret = metadata.meta_title
diff --git a/daras_ai_v2/redis_cache.py b/daras_ai_v2/redis_cache.py
index 4930e5427..f339bec80 100644
--- a/daras_ai_v2/redis_cache.py
+++ b/daras_ai_v2/redis_cache.py
@@ -8,7 +8,6 @@
 
 from daras_ai_v2 import settings
 
-
 LOCK_TIMEOUT_SEC = 10 * 60
 
 
@@ -20,38 +19,44 @@ def get_redis_cache():
 F = typing.TypeVar("F", bound=typing.Callable[..., typing.Any])
 
 
-def redis_cache_decorator(fn: F) -> F:
-    @wraps(fn)
-    def wrapper(*args, **kwargs):
-        # hash the args and kwargs so they are not too long
-        args_hash = hashlib.sha256(f"{args}{kwargs}".encode()).hexdigest()
-        # create a readable cache key
-        cache_key = f"gooey/redis-cache-decorator/v1/{fn.__name__}/{args_hash}"
-        # get the redis cache
-        redis_cache = get_redis_cache()
-        # lock the cache key so that only one thread can run the function
-        lock = redis_cache.lock(
-            name=os.path.join(cache_key, "lock"), timeout=LOCK_TIMEOUT_SEC
-        )
-        try:
-            lock.acquire()
-        except redis.exceptions.LockError:
-            pass
-        try:
-            cache_val = redis_cache.get(cache_key)
-            # if the cache exists, return it
-            if cache_val:
-                return pickle.loads(cache_val)
-            # otherwise, run the function and cache the result
-            else:
-                result = fn(*args, **kwargs)
-                cache_val = pickle.dumps(result)
-                redis_cache.set(cache_key, cache_val)
-                return result
-        finally:
+def redis_cache_decorator(fn: F = None, ex=None) -> F:
+    def decorator(fn: F) -> F:
+        @wraps(fn)
+        def wrapper(*args, **kwargs):
+            # hash the args and kwargs so they are not too long
+            args_hash = hashlib.sha256(f"{args}{kwargs}".encode()).hexdigest()
+            # create a readable cache key
+            cache_key = f"gooey/redis-cache-decorator/v1/{fn.__name__}/{args_hash}"
+            # get the redis cache
+            redis_cache = get_redis_cache()
+            # lock the cache key so that only one thread can run the function
+            lock = redis_cache.lock(
+                name=os.path.join(cache_key, "lock"), timeout=LOCK_TIMEOUT_SEC
+            )
             try:
-                lock.release()
+                lock.acquire()
             except redis.exceptions.LockError:
                 pass
-
-    return wrapper
+            try:
+                cache_val = redis_cache.get(cache_key)
+                # if the cache exists, return it
+                if cache_val:
+                    return pickle.loads(cache_val)
+                # otherwise, run the function and cache the result
+                else:
+                    result = fn(*args, **kwargs)
+                    cache_val = pickle.dumps(result)
+                    redis_cache.set(cache_key, cache_val, ex=ex)
+                    return result
+            finally:
+                try:
+                    lock.release()
+                except redis.exceptions.LockError:
+                    pass
+
+        return wrapper
+
+    if fn is None:
+        return decorator
+    else:
+        return decorator(fn)
diff --git a/daras_ai_v2/safety_checker.py b/daras_ai_v2/safety_checker.py
index 541e41b97..8ae962cc4 100644
--- a/daras_ai_v2/safety_checker.py
+++ b/daras_ai_v2/safety_checker.py
@@ -1,9 +1,15 @@
+from contextlib import contextmanager
+
 from app_users.models import AppUser
+from daras_ai_v2 import settings
 from daras_ai_v2.azure_image_moderation import is_image_nsfw
+from daras_ai_v2.exceptions import UserError
 from daras_ai_v2.functional import flatten
-from daras_ai_v2 import settings
+from gooeysite.bg_db_conn import get_celery_result_db_safe
 from recipes.CompareLLM import CompareLLMPage
 
+SAFETY_CHECKER_MSG = "Your request was rejected as a result of our safety system. Your input image may contain contents that are not allowed by our safety system."
+
 
 def safety_checker(*, text: str | None = None, image: str | None = None):
     assert text or image, "safety_checker: at least one of text, image is required"
@@ -31,7 +37,7 @@ def safety_checker_text(text_input: str):
     )
 
     # wait for checker
-    result.get(disable_sync_subtasks=False)
+    get_celery_result_db_safe(result)
     sr.refresh_from_db()
     # if checker failed, raise error
     if sr.error_msg:
@@ -43,15 +49,21 @@ def safety_checker_text(text_input: str):
         if not lines:
             continue
         if lines[-1].upper().endswith("FLAGGED"):
-            raise ValueError(
-                "Your request was rejected as a result of our safety system. Your prompt may contain text that is not allowed by our safety system."
-            )
+            raise UserError(SAFETY_CHECKER_MSG)
 
 
 def safety_checker_image(image_url: str, cache: bool = False) -> None:
     if is_image_nsfw(image_url=image_url, cache=cache):
-        raise ValueError(
-            "Your request was rejected as a result of our safety system. "
-            "Your input image may contain contents that are not allowed "
-            "by our safety system."
-        )
+        raise UserError(SAFETY_CHECKER_MSG)
+
+
+@contextmanager
+def capture_openai_content_policy_violation():
+    import openai
+
+    try:
+        yield
+    except openai.BadRequestError as e:
+        if e.response.status_code == 400 and "content_policy_violation" in e.message:
+            raise UserError(SAFETY_CHECKER_MSG) from e
+        raise
diff --git a/daras_ai_v2/search_ref.py b/daras_ai_v2/search_ref.py
index 7cc810b1a..e95fb2ab2 100644
--- a/daras_ai_v2/search_ref.py
+++ b/daras_ai_v2/search_ref.py
@@ -161,6 +161,8 @@ def format_citations(
 def format_footnotes(
     all_refs: dict[int, SearchReference], formatted: str, citation_style: CitationStyles
 ) -> str:
+    if not all_refs:
+        return formatted
     match citation_style:
         case CitationStyles.number_markdown:
             formatted += "\n\n"
diff --git a/daras_ai_v2/send_email.py b/daras_ai_v2/send_email.py
index 6c3f0bccb..aaf1eb59b 100644
--- a/daras_ai_v2/send_email.py
+++ b/daras_ai_v2/send_email.py
@@ -1,4 +1,5 @@
 import smtplib
+import sys
 import typing
 from email.mime.application import MIMEApplication
 from email.mime.multipart import MIMEMultipart
@@ -12,6 +13,7 @@
 from daras_ai_v2 import settings
 from daras_ai_v2.settings import templates
 from gooey_ui import UploadedFile
+from routers.billing import account_url
 
 
 def send_reported_run_email(
@@ -43,6 +45,31 @@ def send_reported_run_email(
     )
 
 
+def send_low_balance_email(
+    *,
+    user: AppUser,
+    total_credits_consumed: int,
+):
+    recipeints = "support@gooey.ai, devs@gooey.ai"
+    html_body = templates.get_template("low_balance_email.html").render(
+        user=user,
+        url=account_url,
+        total_credits_consumed=total_credits_consumed,
+        settings=settings,
+    )
+    send_email_via_postmark(
+        from_address=settings.SUPPORT_EMAIL,
+        to_address=user.email or recipeints,
+        bcc=recipeints,
+        subject="Your Gooey.AI credit balance is low",
+        html_body=html_body,
+    )
+
+
+is_running_pytest = "pytest" in sys.modules
+pytest_outbox = []
+
+
 def send_email_via_postmark(
     *,
     from_address: str,
@@ -56,6 +83,21 @@ def send_email_via_postmark(
         "outbound", "gooey-ai-workflows", "announcements"
     ] = "outbound",
 ):
+    if is_running_pytest:
+        pytest_outbox.append(
+            dict(
+                from_address=from_address,
+                to_address=to_address,
+                cc=cc,
+                bcc=bcc,
+                subject=subject,
+                html_body=html_body,
+                text_body=text_body,
+                message_stream=message_stream,
+            ),
+        )
+        return
+
     r = requests.post(
         "https://api.postmarkapp.com/email",
         headers={
diff --git a/daras_ai_v2/settings.py b/daras_ai_v2/settings.py
index 74f38ed5f..8aed12e7b 100644
--- a/daras_ai_v2/settings.py
+++ b/daras_ai_v2/settings.py
@@ -35,7 +35,7 @@
 HASHIDS_SALT = config("HASHIDS_SALT", default="")
 
 ALLOWED_HOSTS = ["*"]
-INTERNAL_IPS = ["127.0.0.1"]
+INTERNAL_IPS = ["127.0.0.1", "localhost"]
 SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
 
 # Application definition
@@ -48,6 +48,7 @@
     "django.contrib.staticfiles",
     "bots",
     "django_extensions",
+    # "debug_toolbar",
     # the order matters, since we want to override the admin templates
     "django.forms",  # needed to override admin forms
     "django.contrib.admin",
@@ -55,6 +56,7 @@
     "files",
     "url_shortener",
     "glossary_resources",
+    "usage_costs",
 ]
 
 MIDDLEWARE = [
@@ -66,6 +68,7 @@
     "django.contrib.auth.middleware.AuthenticationMiddleware",
     "django.contrib.messages.middleware.MessageMiddleware",
     "django.middleware.clickjacking.XFrameOptionsMiddleware",
+    # "debug_toolbar.middleware.DebugToolbarMiddleware",
 ]
 
 ROOT_URLCONF = "gooeysite.urls"
@@ -161,6 +164,8 @@
 
 es_formats.DATETIME_FORMAT = DATETIME_FORMAT
 
+SHORT_DATETIME_FORMAT = "%b %d, %Y %-I:%M %p"
+
 # Static files (CSS, JavaScript, Images)
 # https://docs.djangoproject.com/en/4.2/howto/static-files/
 
@@ -263,6 +268,10 @@
 ANON_USER_FREE_CREDITS = config("ANON_USER_FREE_CREDITS", 25, cast=int)
 LOGIN_USER_FREE_CREDITS = config("LOGIN_USER_FREE_CREDITS", 1000, cast=int)
 
+LOW_BALANCE_EMAIL_CREDITS = config("LOW_BALANCE_EMAIL_CREDITS", 200, cast=int)
+LOW_BALANCE_EMAIL_DAYS = config("LOW_BALANCE_EMAIL_DAYS", 7, cast=int)
+LOW_BALANCE_EMAIL_ENABLED = config("LOW_BALANCE_EMAIL_ENABLED", True, cast=bool)
+
 stripe.api_key = config("STRIPE_SECRET_KEY", None)
 STRIPE_ENDPOINT_SECRET = config("STRIPE_ENDPOINT_SECRET", None)
 
@@ -290,6 +299,8 @@
 REDIS_CACHE_URL = config("REDIS_CACHE_URL", "redis://localhost:6379")
 TWITTER_BEARER_TOKEN = config("TWITTER_BEARER_TOKEN", None)
 
+REDIS_MODELS_CACHE_EXPIRY = 60 * 60 * 24 * 7
+
 GPU_CELERY_BROKER_URL = config("GPU_CELERY_BROKER_URL", "amqp://localhost:5674")
 GPU_CELERY_RESULT_BACKEND = config(
     "GPU_CELERY_RESULT_BACKEND", "redis://localhost:6374"
diff --git a/daras_ai_v2/slack_bot.py b/daras_ai_v2/slack_bot.py
index f75863133..10c88f7d7 100644
--- a/daras_ai_v2/slack_bot.py
+++ b/daras_ai_v2/slack_bot.py
@@ -11,7 +11,7 @@
 from bots.models import BotIntegration, Platform, Conversation
 from daras_ai.image_input import upload_file_from_bytes
 from daras_ai_v2.asr import run_google_translate, audio_bytes_to_wav
-from daras_ai_v2.bots import BotInterface
+from daras_ai_v2.bots import BotInterface, SLACK_MAX_SIZE
 from daras_ai_v2.exceptions import raise_for_status
 from daras_ai_v2.functional import fetch_parallel
 from daras_ai_v2.text_splitter import text_splitter
@@ -27,11 +27,10 @@
 I have been configured for $user_language and will respond to you in that language.
 """.strip()
 
-SLACK_MAX_SIZE = 3000
-
 
 class SlackBot(BotInterface):
     platform = Platform.SLACK
+    can_update_message = True
 
     _read_rcpt_ts: str | None = None
 
@@ -135,6 +134,7 @@ def send_msg(
         buttons: list[ReplyButton] = None,
         documents: list[str] = None,
         should_translate: bool = False,
+        update_msg_id: str | None = None,
     ) -> str | None:
         if text and should_translate and self.language and self.language != "en":
             text = run_google_translate(
@@ -150,7 +150,9 @@ def send_msg(
             )
             self._read_rcpt_ts = None
 
-        self._msg_ts = self.send_msg_to(
+        if not self.can_update_message:
+            update_msg_id = None
+        self._msg_ts, num_splits = self.send_msg_to(
             text=text,
             audio=audio,
             video=video,
@@ -160,7 +162,10 @@ def send_msg(
             username=self.convo.bot_integration.name,
             token=self._access_token,
             thread_ts=self._msg_ts,
+            update_msg_ts=update_msg_id,
         )
+        if num_splits > 1:
+            self.can_update_message = False
         return self._msg_ts
 
     @classmethod
@@ -178,7 +183,8 @@ def send_msg_to(
         username: str,
         token: str,
         thread_ts: str = None,
-    ) -> str | None:
+        update_msg_ts: str = None,
+    ) -> tuple[str | None, int]:
         splits = text_splitter(text, chunk_size=SLACK_MAX_SIZE, length_function=len)
         for doc in splits[:-1]:
             thread_ts = chat_post_message(
@@ -186,9 +192,11 @@ def send_msg_to(
                 channel=channel,
                 channel_is_personal=channel_is_personal,
                 thread_ts=thread_ts,
+                update_msg_ts=update_msg_ts,
                 username=username,
                 token=token,
             )
+            update_msg_ts = None
         thread_ts = chat_post_message(
             text=splits[-1].text,
             audio=audio,
@@ -197,10 +205,11 @@ def send_msg_to(
             channel=channel,
             channel_is_personal=channel_is_personal,
             thread_ts=thread_ts,
+            update_msg_ts=update_msg_ts,
             username=username,
             token=token,
         )
-        return thread_ts
+        return thread_ts, len(splits)
 
     def mark_read(self):
         text = self.convo.bot_integration.slack_read_receipt_msg.strip()
@@ -524,9 +533,10 @@ def chat_post_message(
     channel: str,
     thread_ts: str,
     token: str,
+    update_msg_ts: str = None,
     channel_is_personal: bool = False,
-    audio: str | None = None,
-    video: str | None = None,
+    audio: str = None,
+    video: str = None,
     username: str = "Video Bot",
     buttons: list[ReplyButton] = None,
 ) -> str | None:
@@ -535,28 +545,52 @@ def chat_post_message(
     if channel_is_personal:
         # don't thread in personal channels
         thread_ts = None
-    res = requests.post(
-        "https://slack.com/api/chat.postMessage",
-        json={
-            "channel": channel,
-            "thread_ts": thread_ts,
-            "text": text,
-            "username": username,
-            "icon_emoji": ":robot_face:",
-            "blocks": [
-                {
-                    "type": "section",
-                    "text": {"type": "mrkdwn", "text": text},
-                },
-            ]
-            + create_file_block("Audio", token, audio)
-            + create_file_block("Video", token, video)
-            + create_button_block(buttons),
-        },
-        headers={
-            "Authorization": f"Bearer {token}",
-        },
-    )
+    if update_msg_ts:
+        res = requests.post(
+            "https://slack.com/api/chat.update",
+            json={
+                "channel": channel,
+                "ts": update_msg_ts,
+                "text": text,
+                "username": username,
+                "icon_emoji": ":robot_face:",
+                "blocks": [
+                    {
+                        "type": "section",
+                        "text": {"type": "mrkdwn", "text": text},
+                    },
+                ]
+                + create_file_block("Audio", token, audio)
+                + create_file_block("Video", token, video)
+                + create_button_block(buttons),
+            },
+            headers={
+                "Authorization": f"Bearer {token}",
+            },
+        )
+    else:
+        res = requests.post(
+            "https://slack.com/api/chat.postMessage",
+            json={
+                "channel": channel,
+                "thread_ts": thread_ts,
+                "text": text,
+                "username": username,
+                "icon_emoji": ":robot_face:",
+                "blocks": [
+                    {
+                        "type": "section",
+                        "text": {"type": "mrkdwn", "text": text},
+                    },
+                ]
+                + create_file_block("Audio", token, audio)
+                + create_file_block("Video", token, video)
+                + create_button_block(buttons),
+            },
+            headers={
+                "Authorization": f"Bearer {token}",
+            },
+        )
     data = parse_slack_response(res)
     return data.get("ts")
 
diff --git a/daras_ai_v2/stable_diffusion.py b/daras_ai_v2/stable_diffusion.py
index 22c7adc8e..f68fed2ec 100644
--- a/daras_ai_v2/stable_diffusion.py
+++ b/daras_ai_v2/stable_diffusion.py
@@ -13,12 +13,15 @@
     resize_img_fit,
     get_downscale_factor,
 )
-from daras_ai_v2.exceptions import raise_for_status
+from daras_ai_v2.exceptions import (
+    raise_for_status,
+)
 from daras_ai_v2.extract_face import rgb_img_to_rgba
 from daras_ai_v2.gpu_server import (
     b64_img_decode,
     call_sd_multi,
 )
+from daras_ai_v2.safety_checker import capture_openai_content_policy_violation
 
 SD_IMG_MAX_SIZE = (768, 768)
 
@@ -247,9 +250,9 @@ def instruct_pix2pix(
         },
         inputs={
             "prompt": [prompt] * len(images),
-            "negative_prompt": [negative_prompt] * len(images)
-            if negative_prompt
-            else None,
+            "negative_prompt": (
+                [negative_prompt] * len(images) if negative_prompt else None
+            ),
             "num_images_per_prompt": num_outputs,
             "num_inference_steps": num_inference_steps,
             "guidance_scale": guidance_scale,
@@ -283,27 +286,29 @@ def text2img(
 
             client = OpenAI()
             width, height = _get_dall_e_3_img_size(width, height)
-            response = client.images.generate(
-                model=text2img_model_ids[Text2ImgModels[selected_model]],
-                n=1,  # num_outputs, not supported yet
-                prompt=prompt,
-                response_format="b64_json",
-                quality=dall_e_3_quality,
-                style=dall_e_3_style,
-                size=f"{width}x{height}",
-            )
+            with capture_openai_content_policy_violation():
+                response = client.images.generate(
+                    model=text2img_model_ids[Text2ImgModels[selected_model]],
+                    n=1,  # num_outputs, not supported yet
+                    prompt=prompt,
+                    response_format="b64_json",
+                    quality=dall_e_3_quality,
+                    style=dall_e_3_style,
+                    size=f"{width}x{height}",
+                )
             out_imgs = [b64_img_decode(part.b64_json) for part in response.data]
         case Text2ImgModels.dall_e.name:
             from openai import OpenAI
 
             edge = _get_dall_e_img_size(width, height)
             client = OpenAI()
-            response = client.images.generate(
-                n=num_outputs,
-                prompt=prompt,
-                size=f"{edge}x{edge}",
-                response_format="b64_json",
-            )
+            with capture_openai_content_policy_violation():
+                response = client.images.generate(
+                    n=num_outputs,
+                    prompt=prompt,
+                    size=f"{edge}x{edge}",
+                    response_format="b64_json",
+                )
             out_imgs = [b64_img_decode(part.b64_json) for part in response.data]
         case _:
             prompt = add_prompt_prefix(prompt, selected_model)
@@ -379,12 +384,13 @@ def img2img(
             image = resize_img_pad(init_image_bytes, (edge, edge))
 
             client = OpenAI()
-            response = client.images.create_variation(
-                image=image,
-                n=num_outputs,
-                size=f"{edge}x{edge}",
-                response_format="b64_json",
-            )
+            with capture_openai_content_policy_violation():
+                response = client.images.create_variation(
+                    image=image,
+                    n=num_outputs,
+                    size=f"{edge}x{edge}",
+                    response_format="b64_json",
+                )
 
             out_imgs = [
                 resize_img_fit(b64_img_decode(part.b64_json), (width, height))
@@ -440,9 +446,9 @@ def controlnet(
         pipeline={
             "model_id": text2img_model_ids[Text2ImgModels[selected_model]],
             "seed": seed,
-            "scheduler": Schedulers[scheduler].label
-            if scheduler
-            else "UniPCMultistepScheduler",
+            "scheduler": (
+                Schedulers[scheduler].label if scheduler else "UniPCMultistepScheduler"
+            ),
             "disable_safety_checker": True,
             "controlnet_model_id": [
                 controlnet_model_ids[ControlNetModels[model]]
@@ -503,13 +509,14 @@ def inpainting(
             image = rgb_img_to_rgba(edit_image_bytes, mask_bytes)
 
             client = OpenAI()
-            response = client.images.edit(
-                prompt=prompt,
-                image=image,
-                n=num_outputs,
-                size=f"{edge}x{edge}",
-                response_format="b64_json",
-            )
+            with capture_openai_content_policy_violation():
+                response = client.images.edit(
+                    prompt=prompt,
+                    image=image,
+                    n=num_outputs,
+                    size=f"{edge}x{edge}",
+                    response_format="b64_json",
+                )
             out_imgs = [b64_img_decode(part.b64_json) for part in response.data]
 
         case InpaintingModels.sd_2.name | InpaintingModels.runway_ml.name:
diff --git a/daras_ai_v2/tabs_widget.py b/daras_ai_v2/tabs_widget.py
index f6511e58e..ed643f881 100644
--- a/daras_ai_v2/tabs_widget.py
+++ b/daras_ai_v2/tabs_widget.py
@@ -22,6 +22,14 @@ class MenuTabs:
     }
     paths_reverse = {v: k for k, v in paths.items()}
 
+    display_labels = {
+        examples: "Examples",
+        history: "History",
+        saved: "Saved Runs",
+        run_as_api: "API",
+        integrations: "Integrations",
+    }
+
 
 def page_tabs(*, tabs, key=None):
     selected_menu = option_menu(
diff --git a/daras_ai_v2/text_to_speech_settings_widgets.py b/daras_ai_v2/text_to_speech_settings_widgets.py
index bd9ae8d79..aec7788fe 100644
--- a/daras_ai_v2/text_to_speech_settings_widgets.py
+++ b/daras_ai_v2/text_to_speech_settings_widgets.py
@@ -4,6 +4,7 @@
 from google.cloud import texttospeech
 
 import gooey_ui as st
+from daras_ai_v2 import settings
 from daras_ai_v2.enum_selector_widget import enum_selector
 from daras_ai_v2.exceptions import raise_for_status
 from daras_ai_v2.redis_cache import redis_cache_decorator
@@ -404,7 +405,7 @@ def text_to_speech_settings(
                 )
 
 
-@redis_cache_decorator
+@redis_cache_decorator(ex=settings.REDIS_MODELS_CACHE_EXPIRY)
 def google_tts_voices() -> dict[str, str]:
     voices: list[texttospeech.Voice] = (
         texttospeech.TextToSpeechClient().list_voices().voices
diff --git a/daras_ai_v2/vector_search.py b/daras_ai_v2/vector_search.py
index 394d55b55..6080131ee 100644
--- a/daras_ai_v2/vector_search.py
+++ b/daras_ai_v2/vector_search.py
@@ -31,7 +31,7 @@
 from daras_ai_v2.doc_search_settings_widgets import (
     is_user_uploaded_url,
 )
-from daras_ai_v2.exceptions import raise_for_status
+from daras_ai_v2.exceptions import raise_for_status, call_cmd, UserError
 from daras_ai_v2.fake_user_agents import FAKE_USER_AGENTS
 from daras_ai_v2.functional import flatmap_parallel, map_parallel
 from daras_ai_v2.gdrive_downloader import (
@@ -88,11 +88,11 @@ def get_top_k_references(
     Returns:
         the top k documents
     """
-    yield "Checking docs..."
+    yield "Fetching latest knowledge docs..."
     input_docs = request.documents or []
     doc_metas = map_parallel(doc_url_to_metadata, input_docs)
 
-    yield "Getting embeddings..."
+    yield "Creating knowledge embeddings..."
     embeds: list[tuple[SearchReference, np.ndarray]] = flatmap_parallel(
         lambda f_url, doc_meta: get_embeds_for_doc(
             f_url=f_url,
@@ -107,7 +107,7 @@ def get_top_k_references(
     )
     dense_query_embeds = openai_embedding_create([request.search_query])[0]
 
-    yield "Searching documents..."
+    yield "Searching knowledge base..."
 
     dense_weight = request.dense_weight
     if dense_weight is None:  # for backwards compatibility
@@ -133,7 +133,7 @@ def get_top_k_references(
         dense_ranks = np.zeros(len(embeds))
 
     if sparse_weight:
-        yield "Getting sparse scores..."
+        yield "Considering results..."
         # get sparse scores
         bm25_corpus = flatmap_parallel(
             lambda f_url, doc_meta: get_bm25_embeds_for_doc(
@@ -258,7 +258,7 @@ def doc_url_to_file_metadata(f_url: str) -> FileMetadata:
             meta = gdrive_metadata(url_to_gdrive_file_id(f))
         except HttpError as e:
             if e.status_code == 404:
-                raise FileNotFoundError(
+                raise UserError(
                     f"Could not download the google doc at {f_url} "
                     f"Please make sure to make the document public for viewing."
                 ) from e
@@ -429,11 +429,9 @@ def pages_to_split_refs(
                 "title": (
                     doc_meta.name + (f", page {doc.end + 1}" if len(pages) > 1 else "")
                 ),
-                "url": (
-                    furl(f_url)
-                    .set(fragment_args={"page": doc.end + 1} if len(pages) > 1 else {})
-                    .url
-                ),
+                "url": add_page_number_to_pdf(
+                    f_url, (doc.end + 1 if len(pages) > 1 else f_url)
+                ).url,
                 "snippet": doc.text,
                 **doc.kwargs,
                 "score": -1,
@@ -445,6 +443,10 @@ def pages_to_split_refs(
     return refs
 
 
+def add_page_number_to_pdf(url: str | furl, page_num: int) -> furl:
+    return furl(url).set(fragment_args={"page": page_num} if page_num else {})
+
+
 sections_re = re.compile(r"(\s*[\r\n\f\v]|^)(\w+)\=", re.MULTILINE)
 
 
@@ -628,17 +630,9 @@ def pandoc_to_text(f_name: str, f_bytes: bytes, to="plain") -> str:
         tempfile.NamedTemporaryFile("r") as outfile,
     ):
         infile.write(f_bytes)
-        args = [
-            "pandoc",
-            "--standalone",
-            infile.name,
-            "--to",
-            to,
-            "--output",
-            outfile.name,
-        ]
-        print("\t$ " + " ".join(args))
-        subprocess.check_call(args)
+        call_cmd(
+            "pandoc", "--standalone", infile.name, "--to", to, "--output", outfile.name
+        )
         return outfile.read()
 
 
diff --git a/gooey_ui/components/__init__.py b/gooey_ui/components/__init__.py
index 408b950fb..6322cf629 100644
--- a/gooey_ui/components/__init__.py
+++ b/gooey_ui/components/__init__.py
@@ -217,6 +217,7 @@ def image(
     caption: str = None,
     alt: str = None,
     href: str = None,
+    show_download_button: bool = False,
     **props,
 ):
     if isinstance(src, np.ndarray):
@@ -241,9 +242,18 @@ def image(
             **props,
         ),
     ).mount()
+    if show_download_button:
+        download_button(
+            label='<i class="fa-regular fa-download"></i> Download', url=src
+        )
 
 
-def video(src: str, caption: str = None, autoplay: bool = False):
+def video(
+    src: str,
+    caption: str = None,
+    autoplay: bool = False,
+    show_download_button: bool = False,
+):
     autoplay_props = {}
     if autoplay:
         autoplay_props = {
@@ -266,15 +276,23 @@ def video(src: str, caption: str = None, autoplay: bool = False):
         name="video",
         props=dict(src=src, caption=dedent(caption), **autoplay_props),
     ).mount()
+    if show_download_button:
+        download_button(
+            label='<i class="fa-regular fa-download"></i> Download', url=src
+        )
 
 
-def audio(src: str, caption: str = None):
+def audio(src: str, caption: str = None, show_download_button: bool = False):
     if not src:
         return
     state.RenderTreeNode(
         name="audio",
         props=dict(src=src, caption=dedent(caption)),
     ).mount()
+    if show_download_button:
+        download_button(
+            label='<i class="fa-regular fa-download"></i> Download', url=src
+        )
 
 
 def text_area(
@@ -293,9 +311,7 @@ def text_area(
     #     assert not value, "only one of value or key can be provided"
     # else:
     if not key:
-        key = md5_values(
-            "textarea", label, height, help, value, placeholder, label_visibility
-        )
+        key = md5_values("textarea", label, height, help, placeholder, label_visibility)
     value = str(state.session_state.setdefault(key, value) or "")
     if label_visibility != "visible":
         label = None
@@ -417,6 +433,28 @@ def selectbox(
     return value
 
 
+def download_button(
+    label: str,
+    url: str,
+    key: str = None,
+    help: str = None,
+    *,
+    type: typing.Literal["primary", "secondary", "tertiary", "link"] = "secondary",
+    disabled: bool = False,
+    **props,
+) -> bool:
+    return button(
+        component="download-button",
+        url=url,
+        label=label,
+        key=key,
+        help=help,
+        type=type,
+        disabled=disabled,
+        **props,
+    )
+
+
 def button(
     label: str,
     key: str = None,
@@ -424,6 +462,7 @@ def button(
     *,
     type: typing.Literal["primary", "secondary", "tertiary", "link"] = "secondary",
     disabled: bool = False,
+    component: typing.Literal["download-button", "gui-button"] = "gui-button",
     **props,
 ) -> bool:
     """
@@ -437,7 +476,7 @@ def button(
         key = md5_values("button", label, help, type, props)
     className = f"btn-{type} " + props.pop("className", "")
     state.RenderTreeNode(
-        name="gui-button",
+        name=component,
         props=dict(
             type="submit",
             value="yes",
diff --git a/gooey_ui/pubsub.py b/gooey_ui/pubsub.py
index 5e210c956..ef2ba1539 100644
--- a/gooey_ui/pubsub.py
+++ b/gooey_ui/pubsub.py
@@ -2,6 +2,7 @@
 import json
 import threading
 import typing
+from contextlib import contextmanager
 from time import time
 
 import redis
@@ -49,6 +50,34 @@ def realtime_push(channel: str, value: typing.Any = "ping"):
         logger.info(f"publish {channel=}")
 
 
+@contextmanager
+def realtime_subscribe(channel: str) -> typing.Generator:
+    channel = f"gooey-gui/state/{channel}"
+    pubsub = r.pubsub()
+    pubsub.subscribe(channel)
+    logger.info(f"subscribe {channel=}")
+    try:
+        yield _realtime_sub_gen(channel, pubsub)
+    finally:
+        logger.info(f"unsubscribe {channel=}")
+        pubsub.unsubscribe(channel)
+        pubsub.close()
+
+
+def _realtime_sub_gen(channel: str, pubsub: redis.client.PubSub) -> typing.Generator:
+    while True:
+        message = pubsub.get_message(timeout=10)
+        if not (message and message["type"] == "message"):
+            continue
+        value = json.loads(r.get(channel))
+        if isinstance(value, dict):
+            run_status = value.get("__run_status")
+            logger.info(f"realtime_subscribe: {channel=} {run_status=}")
+        else:
+            logger.info(f"realtime_subscribe: {channel=}")
+        yield value
+
+
 # def use_state(
 #     value: T = None, *, key: str = None
 # ) -> tuple[T, typing.Callable[[T], None]]:
diff --git a/gooeysite/bg_db_conn.py b/gooeysite/bg_db_conn.py
index 9e6a6d3db..0c36daca8 100644
--- a/gooeysite/bg_db_conn.py
+++ b/gooeysite/bg_db_conn.py
@@ -3,11 +3,17 @@
 
 from django.db import reset_queries, close_old_connections
 
+if typing.TYPE_CHECKING:
+    import celery.result
+
 F = typing.TypeVar("F", bound=typing.Callable[..., typing.Any])
 
 
 def db_middleware(fn: F) -> F:
-    """Decorator to ensure the `fn` runs safely in a background task with a new database connection."""
+    """
+    Decorator to ensure the `fn` runs safely in a background task with a new database connection.
+    Workaround for https://code.djangoproject.com/ticket/24810
+    """
 
     @wraps(fn)
     def wrapper(*args, **kwargs):
@@ -19,3 +25,13 @@ def wrapper(*args, **kwargs):
             close_old_connections()
 
     return wrapper
+
+
+next_db_safe = db_middleware(next)
+
+
+@db_middleware
+def get_celery_result_db_safe(
+    result: "celery.result.AsyncResult", **kwargs
+) -> typing.Any:
+    return result.get(disable_sync_subtasks=False, **kwargs)
diff --git a/gooeysite/urls.py b/gooeysite/urls.py
index 767660f21..fba775500 100644
--- a/gooeysite/urls.py
+++ b/gooeysite/urls.py
@@ -14,9 +14,11 @@
     1. Import the include() function: from django.urls import include, path
     2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
 """
+
 from django.contrib import admin
-from django.urls import path
+from django.urls import path, include
 
 urlpatterns = [
+    # path("__debug__/", include("debug_toolbar.urls")),
     path("", admin.site.urls),
 ]
diff --git a/pages/UsageDashboard.py b/pages/UsageDashboard.py
index b4faf6a5d..cd5ec2f88 100644
--- a/pages/UsageDashboard.py
+++ b/pages/UsageDashboard.py
@@ -29,7 +29,6 @@
     Q(email__in=team_emails)
     | Q(email__endswith="gooey.ai")
     | Q(email__endswith="dara.network")
-    | Q(email__endswith="gooey.ai")
     | Q(email__endswith="jaaga.in")
 )
 
diff --git a/poetry.lock b/poetry.lock
index edbc668d1..587185ab8 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -13,13 +13,13 @@ files = [
 
 [[package]]
 name = "aifail"
-version = "0.1.0"
+version = "0.2.0"
 description = ""
 optional = false
 python-versions = ">=3.10,<4.0"
 files = [
-    {file = "aifail-0.1.0-py3-none-any.whl", hash = "sha256:d51fa56b1b8531a298a38cf91a3979f7d427afc88f5af635f86865b8f721bd23"},
-    {file = "aifail-0.1.0.tar.gz", hash = "sha256:40f95fd45c07f9a7f0478d9702e3ea0d811f8582da7f6b841618de2a52803177"},
+    {file = "aifail-0.2.0-py3-none-any.whl", hash = "sha256:83f3a842dbe523ee10a4d53ee00f06e794176122b93b57752566fb98d60db603"},
+    {file = "aifail-0.2.0.tar.gz", hash = "sha256:d3e19e16740577181922055883a00e894d11413d12803e8d443094846040d6df"},
 ]
 
 [package.dependencies]
@@ -323,29 +323,33 @@ files = [
 
 [[package]]
 name = "black"
-version = "23.10.1"
+version = "24.1.1"
 description = "The uncompromising code formatter."
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "black-23.10.1-cp310-cp310-macosx_10_16_arm64.whl", hash = "sha256:ec3f8e6234c4e46ff9e16d9ae96f4ef69fa328bb4ad08198c8cee45bb1f08c69"},
-    {file = "black-23.10.1-cp310-cp310-macosx_10_16_x86_64.whl", hash = "sha256:1b917a2aa020ca600483a7b340c165970b26e9029067f019e3755b56e8dd5916"},
-    {file = "black-23.10.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c74de4c77b849e6359c6f01987e94873c707098322b91490d24296f66d067dc"},
-    {file = "black-23.10.1-cp310-cp310-win_amd64.whl", hash = "sha256:7b4d10b0f016616a0d93d24a448100adf1699712fb7a4efd0e2c32bbb219b173"},
-    {file = "black-23.10.1-cp311-cp311-macosx_10_16_arm64.whl", hash = "sha256:b15b75fc53a2fbcac8a87d3e20f69874d161beef13954747e053bca7a1ce53a0"},
-    {file = "black-23.10.1-cp311-cp311-macosx_10_16_x86_64.whl", hash = "sha256:e293e4c2f4a992b980032bbd62df07c1bcff82d6964d6c9496f2cd726e246ace"},
-    {file = "black-23.10.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d56124b7a61d092cb52cce34182a5280e160e6aff3137172a68c2c2c4b76bcb"},
-    {file = "black-23.10.1-cp311-cp311-win_amd64.whl", hash = "sha256:3f157a8945a7b2d424da3335f7ace89c14a3b0625e6593d21139c2d8214d55ce"},
-    {file = "black-23.10.1-cp38-cp38-macosx_10_16_arm64.whl", hash = "sha256:cfcce6f0a384d0da692119f2d72d79ed07c7159879d0bb1bb32d2e443382bf3a"},
-    {file = "black-23.10.1-cp38-cp38-macosx_10_16_x86_64.whl", hash = "sha256:33d40f5b06be80c1bbce17b173cda17994fbad096ce60eb22054da021bf933d1"},
-    {file = "black-23.10.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:840015166dbdfbc47992871325799fd2dc0dcf9395e401ada6d88fe11498abad"},
-    {file = "black-23.10.1-cp38-cp38-win_amd64.whl", hash = "sha256:037e9b4664cafda5f025a1728c50a9e9aedb99a759c89f760bd83730e76ba884"},
-    {file = "black-23.10.1-cp39-cp39-macosx_10_16_arm64.whl", hash = "sha256:7cb5936e686e782fddb1c73f8aa6f459e1ad38a6a7b0e54b403f1f05a1507ee9"},
-    {file = "black-23.10.1-cp39-cp39-macosx_10_16_x86_64.whl", hash = "sha256:7670242e90dc129c539e9ca17665e39a146a761e681805c54fbd86015c7c84f7"},
-    {file = "black-23.10.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ed45ac9a613fb52dad3b61c8dea2ec9510bf3108d4db88422bacc7d1ba1243d"},
-    {file = "black-23.10.1-cp39-cp39-win_amd64.whl", hash = "sha256:6d23d7822140e3fef190734216cefb262521789367fbdc0b3f22af6744058982"},
-    {file = "black-23.10.1-py3-none-any.whl", hash = "sha256:d431e6739f727bb2e0495df64a6c7a5310758e87505f5f8cde9ff6c0f2d7e4fe"},
-    {file = "black-23.10.1.tar.gz", hash = "sha256:1f8ce316753428ff68749c65a5f7844631aa18c8679dfd3ca9dc1a289979c258"},
+    {file = "black-24.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2588021038bd5ada078de606f2a804cadd0a3cc6a79cb3e9bb3a8bf581325a4c"},
+    {file = "black-24.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1a95915c98d6e32ca43809d46d932e2abc5f1f7d582ffbe65a5b4d1588af7445"},
+    {file = "black-24.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2fa6a0e965779c8f2afb286f9ef798df770ba2b6cee063c650b96adec22c056a"},
+    {file = "black-24.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:5242ecd9e990aeb995b6d03dc3b2d112d4a78f2083e5a8e86d566340ae80fec4"},
+    {file = "black-24.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fc1ec9aa6f4d98d022101e015261c056ddebe3da6a8ccfc2c792cbe0349d48b7"},
+    {file = "black-24.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0269dfdea12442022e88043d2910429bed717b2d04523867a85dacce535916b8"},
+    {file = "black-24.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3d64db762eae4a5ce04b6e3dd745dcca0fb9560eb931a5be97472e38652a161"},
+    {file = "black-24.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:5d7b06ea8816cbd4becfe5f70accae953c53c0e53aa98730ceccb0395520ee5d"},
+    {file = "black-24.1.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:e2c8dfa14677f90d976f68e0c923947ae68fa3961d61ee30976c388adc0b02c8"},
+    {file = "black-24.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a21725862d0e855ae05da1dd25e3825ed712eaaccef6b03017fe0853a01aa45e"},
+    {file = "black-24.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07204d078e25327aad9ed2c64790d681238686bce254c910de640c7cc4fc3aa6"},
+    {file = "black-24.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:a83fe522d9698d8f9a101b860b1ee154c1d25f8a82ceb807d319f085b2627c5b"},
+    {file = "black-24.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:08b34e85170d368c37ca7bf81cf67ac863c9d1963b2c1780c39102187ec8dd62"},
+    {file = "black-24.1.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7258c27115c1e3b5de9ac6c4f9957e3ee2c02c0b39222a24dc7aa03ba0e986f5"},
+    {file = "black-24.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40657e1b78212d582a0edecafef133cf1dd02e6677f539b669db4746150d38f6"},
+    {file = "black-24.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:e298d588744efda02379521a19639ebcd314fba7a49be22136204d7ed1782717"},
+    {file = "black-24.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:34afe9da5056aa123b8bfda1664bfe6fb4e9c6f311d8e4a6eb089da9a9173bf9"},
+    {file = "black-24.1.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:854c06fb86fd854140f37fb24dbf10621f5dab9e3b0c29a690ba595e3d543024"},
+    {file = "black-24.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3897ae5a21ca132efa219c029cce5e6bfc9c3d34ed7e892113d199c0b1b444a2"},
+    {file = "black-24.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:ecba2a15dfb2d97105be74bbfe5128bc5e9fa8477d8c46766505c1dda5883aac"},
+    {file = "black-24.1.1-py3-none-any.whl", hash = "sha256:5cdc2e2195212208fbcae579b931407c1fa9997584f0a415421748aeafff1168"},
+    {file = "black-24.1.1.tar.gz", hash = "sha256:48b5760dcbfe5cf97fd4fba23946681f3a81514c6ab8a45b50da67ac8fbc6c7b"},
 ]
 
 [package.dependencies]
@@ -359,7 +363,7 @@ typing-extensions = {version = ">=4.0.1", markers = "python_version < \"3.11\""}
 
 [package.extras]
 colorama = ["colorama (>=0.4.3)"]
-d = ["aiohttp (>=3.7.4)"]
+d = ["aiohttp (>=3.7.4)", "aiohttp (>=3.7.4,!=3.9.0)"]
 jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"]
 uvloop = ["uvloop (>=0.15.2)"]
 
@@ -6510,4 +6514,4 @@ testing = ["big-O", "jaraco.functools", "jaraco.itertools", "more-itertools", "p
 [metadata]
 lock-version = "2.0"
 python-versions = ">=3.10,<3.13"
-content-hash = "a5ef77e11ff5b9bb9a5ab5ec5a07c2d3ffa0ef3204d332653d3039e8aba04e14"
+content-hash = "798d4cfff5a447e83bd2aa675525c89d6258c927839260a6f20aa71a633a7e81"
diff --git a/pull_request_template.md b/pull_request_template.md
index a41f54e12..38cff8c3d 100644
--- a/pull_request_template.md
+++ b/pull_request_template.md
@@ -1,10 +1,12 @@
 ### Q/A checklist
 
-- [ ] Do a code review of the changes
-- [ ] Add any new dependencies to poetry & export to requirementst.txt (`poetry export -o requirements.txt`) 
+- [ ] Run tests after placing [fixutre.json](https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/ca0f13b8-d6ed-11ee-870b-8e93953183bb/fixture.json) in your project root
+```bash
+ulimit -n unlimited && pytest
+```
+- [ ] Do a self code review of the changes 
 - [ ] Carefully think about the stuff that might break because of this change
 - [ ] The relevant pages still run when you press submit
-- [ ] If you added new settings / knobs, the values get saved if you save it on the UI
 - [ ] The API for those pages still work (API tab)
 - [ ] The public API interface doesn't change if you didn't want it to (check API tab > docs page)
 - [ ] Do your UI changes (if applicable) look acceptable on mobile?
diff --git a/pyproject.toml b/pyproject.toml
index c6a699024..47e46aec9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -56,7 +56,7 @@ django-phonenumber-field = { extras = ["phonenumberslite"], version = "^7.0.2" }
 gunicorn = "^20.1.0"
 psycopg2-binary = "^2.9.6"
 whitenoise = "^6.4.0"
-black = "^23.3.0"
+black = "^24.1.1"
 django-extensions = "^3.2.1"
 pytest-django = "^4.5.2"
 celery = "^5.3.1"
@@ -81,7 +81,7 @@ ua-parser = "^0.18.0"
 user-agents = "^2.2.0"
 openpyxl = "^3.1.2"
 loguru = "^0.7.2"
-aifail = "^0.1.0"
+aifail = "0.2.0"
 pytest-playwright = "^0.4.3"
 
 [tool.poetry.group.dev.dependencies]
@@ -93,3 +93,6 @@ pre-commit = "^3.5.0"
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+--force-exclude = "migrations|node_modules|\\.git|\\.venv|\\.env|\\.pytest_cache|\\.vscode|\\.github|\\.to"
diff --git a/recipes/BulkRunner.py b/recipes/BulkRunner.py
index 15710c410..c4ef5a3c0 100644
--- a/recipes/BulkRunner.py
+++ b/recipes/BulkRunner.py
@@ -19,6 +19,7 @@
     doc_url_to_metadata,
     download_content_bytes,
 )
+from gooeysite.bg_db_conn import get_celery_result_db_safe
 from recipes.DocSearch import render_documents
 
 DEFAULT_BULK_META_IMG = "https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/d80fd4d8-93fa-11ee-bc13-02420a0001cc/Bulk%20Runner.jpg.png"
@@ -301,7 +302,7 @@ def run_v2(
                     result, sr = sr.submit_api_call(
                         current_user=self.request.user, request_body=request_body
                     )
-                    result.get(disable_sync_subtasks=False)
+                    get_celery_result_db_safe(result)
                     sr.refresh_from_db()
 
                     run_time = datetime.timedelta(
@@ -366,7 +367,7 @@ def run_v2(
             result, sr = sr.submit_api_call(
                 current_user=self.request.user, request_body=request_body
             )
-            result.get(disable_sync_subtasks=False)
+            get_celery_result_db_safe(result)
             sr.refresh_from_db()
             response.eval_runs.append(sr.get_app_url())
 
diff --git a/recipes/CompareLLM.py b/recipes/CompareLLM.py
index c07bcffa6..7e709a18d 100644
--- a/recipes/CompareLLM.py
+++ b/recipes/CompareLLM.py
@@ -36,9 +36,9 @@ class CompareLLMPage(BasePage):
 
     class RequestModel(BaseModel):
         input_prompt: str | None
-        selected_models: list[
-            typing.Literal[tuple(e.name for e in LargeLanguageModels)]
-        ] | None
+        selected_models: (
+            list[typing.Literal[tuple(e.name for e in LargeLanguageModels)]] | None
+        )
 
         avoid_repetition: bool | None
         num_outputs: int | None
@@ -59,6 +59,10 @@ def preview_image(self, state: dict) -> str | None:
     def preview_description(self, state: dict) -> str:
         return "Which language model works best your prompt? Compare your text generations across multiple large language models (LLMs) like OpenAI's evolving and latest ChatGPT engines and others like Curie, Ada, Babbage."
 
+    @classmethod
+    def get_example_preferred_fields(cls, state: dict) -> list[str]:
+        return ["input_prompt", "selected_models"]
+
     def render_form_v2(self):
         st.text_area(
             """
@@ -106,8 +110,8 @@ def run(self, state: dict) -> typing.Iterator[str | None]:
                 avoid_repetition=request.avoid_repetition,
                 stream=True,
             )
-            for i, item in enumerate(ret):
-                output_text[selected_model] = item
+            for i, entries in enumerate(ret):
+                output_text[selected_model] = [e["content"] for e in entries]
                 yield f"Streaming{str(i + 1).translate(SUPERSCRIPT)} {model.value}..."
 
     def render_output(self):
diff --git a/recipes/CompareText2Img.py b/recipes/CompareText2Img.py
index e79ef5d54..7b1f421de 100644
--- a/recipes/CompareText2Img.py
+++ b/recipes/CompareText2Img.py
@@ -64,9 +64,9 @@ class RequestModel(BaseModel):
         seed: int | None
         sd_2_upscaling: bool | None
 
-        selected_models: list[
-            typing.Literal[tuple(e.name for e in Text2ImgModels)]
-        ] | None
+        selected_models: (
+            list[typing.Literal[tuple(e.name for e in Text2ImgModels)]] | None
+        )
         scheduler: typing.Literal[tuple(e.name for e in Schedulers)] | None
 
         edit_instruction: str | None
@@ -77,6 +77,10 @@ class ResponseModel(BaseModel):
             typing.Literal[tuple(e.name for e in Text2ImgModels)], list[str]
         ]
 
+    @classmethod
+    def get_example_preferred_fields(cls, state: dict) -> list[str]:
+        return ["selected_models"]
+
     def preview_image(self, state: dict) -> str | None:
         return DEFAULT_COMPARE_TEXT2IMG_META_IMG
 
@@ -96,7 +100,7 @@ def related_workflows(self) -> list:
     def render_form_v2(self):
         st.text_area(
             """
-            ### 👩‍💻 Prompt
+            #### 👩‍💻 Prompt
             Describe the scene that you'd like to generate.
             """,
             key="text_prompt",
@@ -246,7 +250,9 @@ def _render_outputs(self, state):
         for key in selected_models:
             output_images: dict = state.get("output_images", {}).get(key, [])
             for img in output_images:
-                st.image(img, caption=Text2ImgModels[key].value)
+                st.image(
+                    img, caption=Text2ImgModels[key].value, show_download_button=True
+                )
 
     def preview_description(self, state: dict) -> str:
         return "Create multiple AI photos from one prompt using Stable Diffusion (1.5 -> 2.1, Open/Midjourney), DallE, and other models.  Find out which AI Image generator works best for your text prompt on comparing OpenAI, Stability.AI etc."
@@ -262,4 +268,4 @@ def get_raw_price(self, state: dict) -> int:
                     total += 15
                 case _:
                     total += 2
-        return total
+        return total * state.get("num_outputs", 1)
diff --git a/recipes/CompareUpscaler.py b/recipes/CompareUpscaler.py
index f6f4e988b..13f62de91 100644
--- a/recipes/CompareUpscaler.py
+++ b/recipes/CompareUpscaler.py
@@ -24,9 +24,9 @@ class RequestModel(BaseModel):
 
         scale: int
 
-        selected_models: list[
-            typing.Literal[tuple(e.name for e in UpscalerModels)]
-        ] | None
+        selected_models: (
+            list[typing.Literal[tuple(e.name for e in UpscalerModels)]] | None
+        )
 
     class ResponseModel(BaseModel):
         output_images: dict[typing.Literal[tuple(e.name for e in UpscalerModels)], str]
@@ -34,7 +34,7 @@ class ResponseModel(BaseModel):
     def render_form_v2(self):
         st.file_uploader(
             """
-            ### Input Image
+            #### Input Image
             """,
             key="input_image",
             upload_meta=dict(resize=f"{SD_IMG_MAX_SIZE[0] * SD_IMG_MAX_SIZE[1]}@>"),
@@ -107,7 +107,7 @@ def _render_outputs(self, state):
             img: dict = state.get("output_images", {}).get(key)
             if not img:
                 continue
-            st.image(img, caption=UpscalerModels[key].value)
+            st.image(img, caption=UpscalerModels[key].value, show_download_button=True)
 
     def get_raw_price(self, state: dict) -> int:
         selected_models = state.get("selected_models", [])
diff --git a/recipes/DeforumSD.py b/recipes/DeforumSD.py
index 57b5bb9f7..d732e7b0c 100644
--- a/recipes/DeforumSD.py
+++ b/recipes/DeforumSD.py
@@ -1,6 +1,5 @@
 import typing
 import uuid
-from datetime import datetime, timedelta
 
 from django.db.models import TextChoices
 from pydantic import BaseModel
@@ -10,10 +9,10 @@
 from bots.models import Workflow
 from daras_ai_v2.base import BasePage
 from daras_ai_v2.enum_selector_widget import enum_selector
+from daras_ai_v2.exceptions import UserError
 from daras_ai_v2.gpu_server import call_celery_task_outfile
 from daras_ai_v2.loom_video_widget import youtube_video
 from daras_ai_v2.safety_checker import safety_checker
-from daras_ai_v2.tabs_widget import MenuTabs
 
 DEFAULT_DEFORUMSD_META_IMG = "https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/7dc25196-93fe-11ee-9e3a-02420a0001ce/AI%20Animation%20generator.jpg.png"
 
@@ -423,8 +422,8 @@ def render_description(self):
     def render_output(self):
         output_video = st.session_state.get("output_video")
         if output_video:
-            st.write("Output Video")
-            st.video(output_video, autoplay=True)
+            st.write("#### Output Video")
+            st.video(output_video, autoplay=True, show_download_button=True)
 
     def estimate_run_duration(self):
         # in seconds
@@ -455,27 +454,32 @@ def run(self, state: dict):
         if not self.request.user.disable_safety_checker:
             safety_checker(text=self.preview_input(state))
 
-        state["output_video"] = call_celery_task_outfile(
-            "deforum",
-            pipeline=dict(
-                model_id=AnimationModels[request.selected_model].value,
-                seed=request.seed,
-            ),
-            inputs=dict(
-                animation_mode=request.animation_mode,
-                animation_prompts={
-                    fp["frame"]: fp["prompt"] for fp in request.animation_prompts
-                },
-                max_frames=request.max_frames,
-                zoom=request.zoom,
-                translation_x=request.translation_x,
-                translation_y=request.translation_y,
-                rotation_3d_x=request.rotation_3d_x,
-                rotation_3d_y=request.rotation_3d_y,
-                rotation_3d_z=request.rotation_3d_z,
-                translation_z="0:(0)",
-                fps=request.fps,
-            ),
-            content_type="video/mp4",
-            filename=f"gooey.ai animation {request.animation_prompts}.mp4",
-        )[0]
+        try:
+            state["output_video"] = call_celery_task_outfile(
+                "deforum",
+                pipeline=dict(
+                    model_id=AnimationModels[request.selected_model].value,
+                    seed=request.seed,
+                ),
+                inputs=dict(
+                    animation_mode=request.animation_mode,
+                    animation_prompts={
+                        fp["frame"]: fp["prompt"] for fp in request.animation_prompts
+                    },
+                    max_frames=request.max_frames,
+                    zoom=request.zoom,
+                    translation_x=request.translation_x,
+                    translation_y=request.translation_y,
+                    rotation_3d_x=request.rotation_3d_x,
+                    rotation_3d_y=request.rotation_3d_y,
+                    rotation_3d_z=request.rotation_3d_z,
+                    translation_z="0:(0)",
+                    fps=request.fps,
+                ),
+                content_type="video/mp4",
+                filename=f"gooey.ai animation {request.animation_prompts}.mp4",
+            )[0]
+        except RuntimeError as e:
+            msg = "\n\n".join(e.args).lower()
+            if "key frame string not correctly formatted" in msg:
+                raise UserError(str(e)) from e
diff --git a/recipes/DocExtract.py b/recipes/DocExtract.py
index 6c9489fff..e9eaad6ae 100644
--- a/recipes/DocExtract.py
+++ b/recipes/DocExtract.py
@@ -1,5 +1,6 @@
-import io
 import random
+import subprocess
+import tempfile
 import threading
 import typing
 
@@ -26,7 +27,7 @@
 from daras_ai_v2.base import BasePage
 from daras_ai_v2.doc_search_settings_widgets import document_uploader
 from daras_ai_v2.enum_selector_widget import enum_selector
-from daras_ai_v2.exceptions import raise_for_status
+from daras_ai_v2.exceptions import raise_for_status, call_cmd
 from daras_ai_v2.fake_user_agents import FAKE_USER_AGENTS
 from daras_ai_v2.functional import (
     apply_parallel,
@@ -38,21 +39,22 @@
 from daras_ai_v2.language_model_settings_widgets import language_model_settings
 from daras_ai_v2.loom_video_widget import youtube_video
 from daras_ai_v2.settings import service_account_key_path
-from daras_ai_v2.vector_search import doc_url_to_metadata
+from daras_ai_v2.vector_search import doc_url_to_metadata, add_page_number_to_pdf
 from recipes.DocSearch import render_documents
 
 DEFAULT_YOUTUBE_BOT_META_IMG = "https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/ddc8ffac-93fb-11ee-89fb-02420a0001cb/Youtube%20transcripts.jpg.png"
 
 
 class Columns(IntegerChoices):
-    webpage_url = 1, "Source"
-    title = 2, "Title"
-    description = 3, "Description"
-    content_url = 4, "Content"
-    transcript = 5, "Transcript"
-    translation = 6, "Translation"
-    summary = 7, "Summarized"
-    status = 8, "Status"
+    webpage_url = 1, "url"
+    title = 2, "title"
+    final_output = 3, "snippet/sections"
+    description = 4, "Description"
+    content_url = 5, "Content URL"
+    transcript = 6, "Transcript"
+    translation = 7, "Translation"
+    summary = 8, "Summarized"
+    status = 9, "Status"
 
 
 class DocExtractPage(BasePage):
@@ -77,9 +79,9 @@ class RequestModel(BaseModel):
 
         task_instructions: str | None
 
-        selected_model: typing.Literal[
-            tuple(e.name for e in LargeLanguageModels)
-        ] | None
+        selected_model: (
+            typing.Literal[tuple(e.name for e in LargeLanguageModels)] | None
+        )
         avoid_repetition: bool | None
         num_outputs: int | None
         quality: float | None
@@ -94,11 +96,11 @@ def preview_image(self, state: dict) -> str | None:
 
     def render_form_v2(self):
         document_uploader(
-            "##### 🤖 Youtube URLS",
+            "#### 🤖 Youtube URLS",
             accept=("audio/*", "application/pdf", "video/*"),
         )
         st.text_input(
-            "##### 📊 Google Sheets URL",
+            "#### 📊 Google Sheets URL",
             key="sheet_url",
         )
 
@@ -148,7 +150,10 @@ def run(self, state: dict) -> typing.Iterator[str | None]:
         request: DocExtractPage.RequestModel = self.RequestModel.parse_obj(state)
 
         entries = yield from flatapply_parallel(
-            extract_info, request.documents, message="Extracting metadata..."
+            extract_info,
+            request.documents,
+            message="Extracting metadata...",
+            max_workers=50,
         )
 
         yield "Preparing sheet..."
@@ -265,8 +270,6 @@ def col_i2a(col: int) -> str:
 
 
 def extract_info(url: str) -> list[dict | None]:
-    from pypdf import PdfReader
-
     if is_yt_url(url):
         import yt_dlp
 
@@ -274,8 +277,11 @@ def extract_info(url: str) -> list[dict | None]:
         params = dict(ignoreerrors=True, check_formats=False)
         with yt_dlp.YoutubeDL(params) as ydl:
             data = ydl.extract_info(url, download=False)
-        entries = data.get("entries", [data])
-        return [e for e in entries if e]
+        if data:
+            entries = data.get("entries", [data])
+            return [e for e in entries if e]
+        else:
+            return [{"webpage_url": url, "title": "Youtube Video"}]
     else:
         # assume it's a direct link
         doc_meta = doc_url_to_metadata(url)
@@ -285,6 +291,9 @@ def extract_info(url: str) -> list[dict | None]:
             f = furl(url)
             if is_gdrive_url(f):
                 f_bytes, _ = gdrive_download(f, doc_meta.mime_type)
+                content_url = upload_file_from_bytes(
+                    doc_meta.name, f_bytes, content_type=doc_meta.mime_type
+                )
             else:
                 r = requests.get(
                     url,
@@ -293,18 +302,41 @@ def extract_info(url: str) -> list[dict | None]:
                 )
                 raise_for_status(r)
                 f_bytes = r.content
-            inputpdf = PdfReader(io.BytesIO(f_bytes))
+                content_url = url
+            num_pages = get_pdf_num_pages(f_bytes)
             return [
                 {
-                    "webpage_url": f.copy().set(fragment_args={"page": i + 1}).url,
-                    "pdf_page": page,
-                    "title": (doc_meta.name + f", page {i + 1}"),
+                    "webpage_url": add_page_number_to_pdf(f, page_num).url,
+                    "title": f"{doc_meta.name}, page {page_num}",
                     "doc_meta": doc_meta,
+                    # "pdf_page": page,
+                    "content_url": add_page_number_to_pdf(content_url, page_num).url,
+                    "page_num": page_num,
                 }
-                for i, page in enumerate(inputpdf.pages)
+                for i in range(num_pages)
+                if (page_num := i + 1)
+            ]
+        else:
+            return [
+                {
+                    "webpage_url": url,
+                    "title": doc_meta.name,
+                    "doc_meta": doc_meta,
+                },
             ]
 
-        return [{"webpage_url": url, "title": doc_meta.name, "doc_meta": doc_meta}]
+
+def get_pdf_num_pages(f_bytes: bytes) -> int:
+    with tempfile.NamedTemporaryFile() as infile:
+        infile.write(f_bytes)
+        output = call_cmd("pdfinfo", infile.name).lower()
+        for line in output.splitlines():
+            if not line.startswith("pages:"):
+                continue
+            try:
+                return int(line.split("pages:")[-1])
+            except ValueError:
+                raise ValueError(f"Unexpected PDF Info: {line}")
 
 
 def process_entry(
@@ -338,8 +370,6 @@ def process_source(
     row: int,
     entry: dict,
 ) -> typing.Iterator[str | None]:
-    from pypdf import PdfWriter
-
     webpage_url = entry["webpage_url"]
     doc_meta = entry.get("doc_meta")
 
@@ -357,11 +387,16 @@ def process_source(
     )
 
     content_url = existing_values[Columns.content_url.value]
+    is_yt = is_yt_url(webpage_url)
+    is_pdf = doc_meta and "application/pdf" in doc_meta.mime_type
+    is_video = doc_meta and (
+        "video/" in doc_meta.mime_type or "audio/" in doc_meta.mime_type
+    )
     if not content_url:
         yield "Downloading"
-        if is_yt_url(webpage_url):
+        if is_yt:
             content_url, _ = download_youtube_to_wav(webpage_url)
-        elif "video/" in doc_meta.mime_type or "audio/" in doc_meta.mime_type:
+        elif is_video:
             f = furl(webpage_url)
             if is_gdrive_url(f):
                 f_bytes, _ = gdrive_download(f, doc_meta.mime_type)
@@ -369,15 +404,8 @@ def process_source(
                     doc_meta.name, f_bytes, content_type=doc_meta.mime_type
                 )
             content_url, _ = audio_url_to_wav(webpage_url)
-        elif "application/pdf" in doc_meta.mime_type:
-            page = entry["pdf_page"]
-            outputpdf = PdfWriter()
-            outputpdf.add_page(page)
-            with io.BytesIO() as outf:
-                outputpdf.write(outf)
-                content_url = upload_file_from_bytes(
-                    entry["title"], outf.getvalue(), content_type="application/pdf"
-                )
+        elif is_pdf:
+            content_url = entry.get("content_url") or webpage_url
         else:
             raise NotImplementedError(
                 f"Unsupported type {doc_meta and doc_meta.mime_type} for {webpage_url}"
@@ -386,22 +414,32 @@ def process_source(
 
     transcript = existing_values[Columns.transcript.value]
     if not transcript:
-        if (
-            is_yt_url(webpage_url)
-            or "video/" in doc_meta.mime_type
-            or "audio/" in doc_meta.mime_type
-        ):
+        if is_yt or is_video:
             yield "Transcribing"
             transcript = run_asr(content_url, request.selected_asr_model)
-        elif "application/pdf" in doc_meta.mime_type:
+        elif is_pdf:
             yield "Extracting PDF"
-            transcript = str(azure_doc_extract_pages(content_url)[0])
+            if page_num := entry.get("page_num"):
+                params = dict(pages=str(page_num))
+            else:
+                params = None
+            pages = azure_doc_extract_pages(content_url, params=params)
+            if pages and pages[0]:
+                transcript = str(pages[0])
+            else:
+                transcript = ""
         else:
             raise NotImplementedError(
                 f"Unsupported type {doc_meta and doc_meta.mime_type} for {webpage_url}"
             )
         update_cell(spreadsheet_id, row, Columns.transcript.value, transcript)
 
+    if is_pdf:
+        final_col_name = "sections"
+    else:
+        final_col_name = "snippet"
+    final_value = transcript
+
     if request.google_translate_target:
         translation = existing_values[Columns.translation.value]
         if not translation:
@@ -413,32 +451,47 @@ def process_source(
                 glossary_url=request.glossary_document,
             )[0]
             update_cell(spreadsheet_id, row, Columns.translation.value, translation)
+        final_value = translation
     else:
         translation = transcript
         update_cell(spreadsheet_id, row, Columns.translation.value, "")
 
     summary = existing_values[Columns.summary.value]
-    if not summary and request.task_instructions:
-        yield "Summarizing"
-        prompt = request.task_instructions.strip() + "\n\n" + translation
-        summary = "\n---\n".join(
-            run_language_model(
-                model=request.selected_model,
-                quality=request.quality,
-                num_outputs=request.num_outputs,
-                temperature=request.sampling_temperature,
-                prompt=prompt,
-                max_tokens=request.max_tokens,
-                avoid_repetition=request.avoid_repetition,
+    if request.task_instructions:
+        if not summary:
+            yield "Summarizing"
+            prompt = request.task_instructions.strip() + "\n\n" + translation
+            summary = "\n---\n".join(
+                run_language_model(
+                    model=request.selected_model,
+                    quality=request.quality,
+                    num_outputs=request.num_outputs,
+                    temperature=request.sampling_temperature,
+                    prompt=prompt,
+                    max_tokens=request.max_tokens,
+                    avoid_repetition=request.avoid_repetition,
+                )
             )
-        )
-        update_cell(spreadsheet_id, row, Columns.summary.value, summary)
+            update_cell(spreadsheet_id, row, Columns.summary.value, summary)
+        if final_col_name != "sections":
+            final_value = f"content={final_value}\ncontent={summary}"
+            final_col_name = "sections"
+        else:
+            final_value = f"{final_value}\ncontent={summary}"
+    else:
+        update_cell(spreadsheet_id, row, Columns.summary.value, "")
+
+    update_cell(spreadsheet_id, 1, Columns.final_output.value, final_col_name)
+    update_cell(spreadsheet_id, row, Columns.final_output.value, final_value)
 
 
 def google_api_should_retry(e: Exception) -> bool:
-    return isinstance(e, HttpError) and (
-        e.resp.status in (408, 429) or e.resp.status > 500
-    )
+    from googleapiclient.errors import HttpError
+
+    return (
+        isinstance(e, HttpError)
+        and (e.resp.status in (408, 429) or e.resp.status > 500)
+    ) or isinstance(e, TimeoutError)
 
 
 @retry_if(google_api_should_retry)
diff --git a/recipes/DocSearch.py b/recipes/DocSearch.py
index 15cb6b063..322cafbd9 100644
--- a/recipes/DocSearch.py
+++ b/recipes/DocSearch.py
@@ -61,9 +61,9 @@ class RequestModel(DocSearchRequest):
         task_instructions: str | None
         query_instructions: str | None
 
-        selected_model: typing.Literal[
-            tuple(e.name for e in LargeLanguageModels)
-        ] | None
+        selected_model: (
+            typing.Literal[tuple(e.name for e in LargeLanguageModels)] | None
+        )
         avoid_repetition: bool | None
         num_outputs: int | None
         quality: float | None
@@ -81,9 +81,13 @@ class ResponseModel(BaseModel):
         final_prompt: str
         final_search_query: str | None
 
+    @classmethod
+    def get_example_preferred_fields(self, state: dict) -> list[str]:
+        return ["documents"]
+
     def render_form_v2(self):
-        st.text_area("##### Search Query", key="search_query")
-        document_uploader("##### Documents")
+        st.text_area("#### Search Query", key="search_query")
+        document_uploader("#### Documents")
         prompt_vars_widget("task_instructions", "query_instructions")
 
     def validate_form_v2(self):
@@ -111,7 +115,7 @@ def render_output(self):
 
     def render_example(self, state: dict):
         render_documents(state)
-        st.write("**Search Query**")
+        st.html("**Search Query**")
         st.write("```properties\n" + state.get("search_query", "") + "\n```")
         render_output_with_refs(state, 200)
 
@@ -205,9 +209,10 @@ def run_v2(
     def get_raw_price(self, state: dict) -> float:
         name = state.get("selected_model")
         try:
-            return llm_price[LargeLanguageModels[name]] * 2
+            unit_price = llm_price[LargeLanguageModels[name]] * 2
         except KeyError:
-            return 10
+            unit_price = 10
+        return unit_price * state.get("num_outputs", 1)
 
 
 def render_documents(state, label="**Documents**", *, key="documents"):
diff --git a/recipes/DocSummary.py b/recipes/DocSummary.py
index 4b9283cde..8955d5e59 100644
--- a/recipes/DocSummary.py
+++ b/recipes/DocSummary.py
@@ -60,9 +60,9 @@ class RequestModel(BaseModel):
         task_instructions: str | None
         merge_instructions: str | None
 
-        selected_model: typing.Literal[
-            tuple(e.name for e in LargeLanguageModels)
-        ] | None
+        selected_model: (
+            typing.Literal[tuple(e.name for e in LargeLanguageModels)] | None
+        )
         avoid_repetition: bool | None
         num_outputs: int | None
         quality: float | None
@@ -80,12 +80,16 @@ class ResponseModel(BaseModel):
         prompt_tree: PromptTree | None
         final_prompt: str
 
+    @classmethod
+    def get_example_preferred_fields(cls, state: dict) -> list[str]:
+        return ["task_instructions", "merge_instructions"]
+
     def preview_image(self, state: dict) -> str | None:
         return DEFAULT_DOC_SUMMARY_META_IMG
 
     def render_form_v2(self):
-        document_uploader("##### 📎 Documents")
-        st.text_area("##### 👩‍💻 Instructions", key="task_instructions", height=150)
+        document_uploader("#### 📎 Documents")
+        st.text_area("#### 👩‍💻 Instructions", key="task_instructions", height=150)
 
     def render_settings(self):
         st.text_area(
diff --git a/recipes/EmailFaceInpainting.py b/recipes/EmailFaceInpainting.py
index 74749bdb5..385596f6d 100644
--- a/recipes/EmailFaceInpainting.py
+++ b/recipes/EmailFaceInpainting.py
@@ -88,6 +88,10 @@ class ResponseModel(BaseModel):
         output_images: list[str]
         email_sent: bool = False
 
+    @classmethod
+    def get_example_preferred_fields(self, state: dict) -> list[str]:
+        return ["email_address"]
+
     def preview_image(self, state: dict) -> str | None:
         return DEFAULT_EMAIL_FACE_INPAINTING_META_IMG
 
@@ -115,7 +119,7 @@ def render_description(self):
     def render_form_v2(self):
         st.text_area(
             """
-            ### Prompt
+            #### Prompt
             Describe the scene that you'd like to generate around the face. 
             """,
             key="text_prompt",
@@ -130,7 +134,7 @@ def render_form_v2(self):
 
         source = st.radio(
             """
-            ### Photo Source
+            #### Photo Source
             From where we should get the photo?""",
             options=["Email Address", "Twitter Handle"],
             key="__photo_source",
diff --git a/recipes/FaceInpainting.py b/recipes/FaceInpainting.py
index ee377b53d..2f1b6a0b0 100644
--- a/recipes/FaceInpainting.py
+++ b/recipes/FaceInpainting.py
@@ -105,7 +105,7 @@ def render_description(self):
     def render_form_v2(self):
         st.text_area(
             """
-            ### Prompt
+            #### Prompt
             Describe the character that you'd like to generate. 
             """,
             key="text_prompt",
@@ -114,7 +114,7 @@ def render_form_v2(self):
 
         st.file_uploader(
             """
-            ### Face Photo
+            #### Face Photo
             Give us a photo of yourself, or anyone else
             """,
             key="input_image",
@@ -196,11 +196,9 @@ def render_output(self):
         output_images = st.session_state.get("output_images")
 
         if output_images:
+            st.write("#### Output Image")
             for url in output_images:
-                st.image(
-                    url,
-                    caption="```" + text_prompt.replace("\n", "") + "```",
-                )
+                st.image(url, show_download_button=True)
         else:
             st.div()
 
@@ -338,6 +336,8 @@ def get_raw_price(self, state: dict) -> int:
         selected_model = state.get("selected_model")
         match selected_model:
             case InpaintingModels.dall_e.name:
-                return 20
+                unit_price = 20
             case _:
-                return 5
+                unit_price = 5
+
+        return unit_price * state.get("num_outputs", 1)
diff --git a/recipes/GoogleGPT.py b/recipes/GoogleGPT.py
index 57b1078ba..35d650acb 100644
--- a/recipes/GoogleGPT.py
+++ b/recipes/GoogleGPT.py
@@ -79,9 +79,9 @@ class RequestModel(GoogleSearchMixin, BaseModel):
         task_instructions: str | None
         query_instructions: str | None
 
-        selected_model: typing.Literal[
-            tuple(e.name for e in LargeLanguageModels)
-        ] | None
+        selected_model: (
+            typing.Literal[tuple(e.name for e in LargeLanguageModels)] | None
+        )
         avoid_repetition: bool | None
         num_outputs: int | None
         quality: float | None
@@ -111,7 +111,7 @@ class ResponseModel(BaseModel):
         final_search_query: str | None
 
     def render_form_v2(self):
-        st.text_area("##### Google Search Query", key="search_query")
+        st.text_area("#### Google Search Query", key="search_query")
         st.text_input("Search on a specific site *(optional)*", key="site_filter")
         prompt_vars_widget("task_instructions", "query_instructions")
 
diff --git a/recipes/GoogleImageGen.py b/recipes/GoogleImageGen.py
index c3dab52f0..278128a37 100644
--- a/recipes/GoogleImageGen.py
+++ b/recipes/GoogleImageGen.py
@@ -180,7 +180,7 @@ def run(self, state: dict):
     def render_form_v2(self):
         st.text_input(
             """
-            ### 🔎 Google Image Search
+            #### 🔎 Google Image Search
             Type a query you'd use in [Google image search](https://images.google.com/?gws_rd=ssl)
             """,
             key="search_query",
@@ -188,7 +188,7 @@ def render_form_v2(self):
         model_selector(Img2ImgModels)
         st.text_area(
             """
-            ### 👩‍💻 Prompt
+            #### 👩‍💻 Prompt
             Describe how you want to edit the photo in words
             """,
             key="text_prompt",
@@ -206,7 +206,7 @@ def render_output(self):
         out_imgs = st.session_state.get("output_images")
         if out_imgs:
             for img in out_imgs:
-                st.image(img, caption="Generated Image")
+                st.image(img, caption="#### Generated Image", show_download_button=True)
         else:
             st.div()
 
diff --git a/recipes/ImageSegmentation.py b/recipes/ImageSegmentation.py
index 543664065..c247fdeda 100644
--- a/recipes/ImageSegmentation.py
+++ b/recipes/ImageSegmentation.py
@@ -49,9 +49,9 @@ class ImageSegmentationPage(BasePage):
     class RequestModel(BaseModel):
         input_image: str
 
-        selected_model: typing.Literal[
-            tuple(e.name for e in ImageSegmentationModels)
-        ] | None
+        selected_model: (
+            typing.Literal[tuple(e.name for e in ImageSegmentationModels)] | None
+        )
         mask_threshold: float | None
 
         rect_persepective_transform: bool | None
@@ -86,7 +86,7 @@ def related_workflows(self) -> list:
     def render_form_v2(self):
         st.file_uploader(
             """
-            ### Input Photo
+            #### Input Photo
             Give us a photo of anything
             """,
             key="input_image",
@@ -342,7 +342,7 @@ def render_example(self, state: dict):
         with col1:
             input_image = state.get("input_image")
             if input_image:
-                st.image(input_image, caption="Input Photo")
+                st.image(input_image, caption="Input Photo", show_download_button=True)
             else:
                 st.div()
 
diff --git a/recipes/Img2Img.py b/recipes/Img2Img.py
index a97bc7c62..41a1139e4 100644
--- a/recipes/Img2Img.py
+++ b/recipes/Img2Img.py
@@ -46,9 +46,11 @@ class RequestModel(BaseModel):
         text_prompt: str | None
 
         selected_model: typing.Literal[tuple(e.name for e in Img2ImgModels)] | None
-        selected_controlnet_model: list[
-            typing.Literal[tuple(e.name for e in ControlNetModels)]
-        ] | typing.Literal[tuple(e.name for e in ControlNetModels)] | None
+        selected_controlnet_model: (
+            list[typing.Literal[tuple(e.name for e in ControlNetModels)]]
+            | typing.Literal[tuple(e.name for e in ControlNetModels)]
+            | None
+        )
         negative_prompt: str | None
 
         num_outputs: int | None
@@ -70,6 +72,10 @@ class RequestModel(BaseModel):
     class ResponseModel(BaseModel):
         output_images: list[str]
 
+    @classmethod
+    def get_example_preferred_fields(self, state: dict) -> list[str]:
+        return ["text_prompt"]
+
     def preview_image(self, state: dict) -> str | None:
         return DEFAULT_IMG2IMG_META_IMG
 
@@ -89,7 +95,7 @@ def related_workflows(self) -> list:
     def render_form_v2(self):
         st.file_uploader(
             """
-            ### Input Image
+            #### Input Image
             """,
             key="input_image",
             upload_meta=dict(resize=f"{SD_IMG_MAX_SIZE[0] * SD_IMG_MAX_SIZE[1]}@>"),
@@ -98,7 +104,7 @@ def render_form_v2(self):
         if st.session_state.get("selected_model") != InpaintingModels.dall_e.name:
             st.text_area(
                 """
-                ### Prompt
+                #### Prompt
                 Describe your edits 
                 """,
                 key="text_prompt",
@@ -125,11 +131,12 @@ def render_usage_guide(self):
         youtube_video("narcZNyuNAg")
 
     def render_output(self):
-        text_prompt = st.session_state.get("text_prompt", "")
         output_images = st.session_state.get("output_images", [])
-
+        if not output_images:
+            return
+        st.write("#### Output Image")
         for img in output_images:
-            st.image(img, caption="```" + text_prompt.replace("\n", "") + "```")
+            st.image(img, show_download_button=True)
 
     def render_example(self, state: dict):
         col1, col2 = st.columns(2)
@@ -199,6 +206,8 @@ def get_raw_price(self, state: dict) -> int:
         selected_model = state.get("selected_model")
         match selected_model:
             case Img2ImgModels.dall_e.name:
-                return 20
+                unit_price = 20
             case _:
-                return 5
+                unit_price = 5
+
+        return unit_price * state.get("num_outputs", 1)
diff --git a/recipes/Lipsync.py b/recipes/Lipsync.py
index 5fe08a09b..c2ac64369 100644
--- a/recipes/Lipsync.py
+++ b/recipes/Lipsync.py
@@ -82,33 +82,12 @@ def run(self, state: dict) -> typing.Iterator[str | None]:
         )
 
     def render_example(self, state: dict):
-        col1, col2 = st.columns(2)
-
-        with col1:
-            input_face = state.get("input_face")
-            if not input_face:
-                st.div()
-            elif input_face.endswith(".mp4") or input_face.endswith(".mov"):
-                st.write("Input Face (Video)")
-                st.video(input_face)
-            else:
-                st.write("Input Face (Image)")
-                st.image(input_face)
-
-            input_audio = state.get("input_audio")
-            if input_audio:
-                st.write("Input Audio")
-                st.audio(input_audio)
-            else:
-                st.div()
-
-        with col2:
-            output_video = state.get("output_video")
-            if output_video:
-                st.write("Output Video")
-                st.video(output_video, autoplay=True)
-            else:
-                st.div()
+        output_video = state.get("output_video")
+        if output_video:
+            st.write("#### Output Video")
+            st.video(output_video, autoplay=True, show_download_button=True)
+        else:
+            st.div()
 
     def render_output(self):
         self.render_example(st.session_state)
@@ -145,3 +124,31 @@ def get_raw_price(self, state: dict) -> float:
 
         total_mb = total_bytes / 1024 / 1024
         return total_mb * CREDITS_PER_MB
+
+    def download_blob(self, bucket_name, source_blob_name, destination_file_name):
+        """Downloads a blob from the bucket."""
+        # The ID of your GCS bucket
+        # bucket_name = "your-bucket-name"
+
+        # The ID of your GCS object
+        # source_blob_name = "storage-object-name"
+
+        # The path to which the file should be downloaded
+        # destination_file_name = "local/path/to/file"
+
+        storage_client = storage.Client()
+
+        bucket = storage_client.bucket(bucket_name)
+
+        # Construct a client side representation of a blob.
+        # Note `Bucket.blob` differs from `Bucket.get_blob` as it doesn't retrieve
+        # any content from Google Cloud Storage. As we don't need additional data,
+        # using `Bucket.blob` is preferred here.
+        blob = bucket.blob(source_blob_name)
+        blob.download_to_filename(destination_file_name)
+
+        print(
+            "Downloaded storage object {} from bucket {} to local file {}.".format(
+                source_blob_name, bucket_name, destination_file_name
+            )
+        )
diff --git a/recipes/LipsyncTTS.py b/recipes/LipsyncTTS.py
index 60886c017..1fc0f6c64 100644
--- a/recipes/LipsyncTTS.py
+++ b/recipes/LipsyncTTS.py
@@ -127,37 +127,16 @@ def run(self, state: dict) -> typing.Iterator[str | None]:
         yield from LipsyncPage.run(self, state)
 
     def render_example(self, state: dict):
-        col1, col2 = st.columns(2)
-
-        with col1:
-            input_face = state.get("input_face")
-            if not input_face:
-                pass
-            elif input_face.endswith(".mp4") or input_face.endswith(".mov"):
-                st.video(input_face, caption="Input Face (Video)")
-            else:
-                st.image(input_face, caption="Input Face (Image)")
-
-            input_text = state.get("text_prompt")
-            if input_text:
-                st.write("**Input Text**")
-                st.write(input_text)
-            else:
-                st.div()
-
-            # input_audio = state.get("input_audio")
-            # if input_audio:
-            #    st.write("Synthesized Voice")
-            #    st.audio(input_audio)
-            # else:
-            #    st.empty()
-
-        with col2:
-            output_video = state.get("output_video")
-            if output_video:
-                st.video(output_video, caption="Output Video", autoplay=True)
-            else:
-                st.div()
+        output_video = state.get("output_video")
+        if output_video:
+            st.video(
+                output_video,
+                caption="#### Output Video",
+                autoplay=True,
+                show_download_button=True,
+            )
+        else:
+            st.div()
 
     def render_output(self):
         self.render_example(st.session_state)
diff --git a/recipes/ObjectInpainting.py b/recipes/ObjectInpainting.py
index d84c59069..db12760bf 100644
--- a/recipes/ObjectInpainting.py
+++ b/recipes/ObjectInpainting.py
@@ -95,7 +95,7 @@ def related_workflows(self) -> list:
     def render_form_v2(self):
         st.text_area(
             """
-            ### Prompt
+            #### Prompt
             Describe the scene that you'd like to generate. 
             """,
             key="text_prompt",
@@ -104,7 +104,7 @@ def render_form_v2(self):
 
         st.file_uploader(
             """
-            ### Object Photo
+            #### Object Photo
             Give us a photo of anything
             """,
             key="input_image",
@@ -201,7 +201,7 @@ def render_output(self):
 
         if output_images:
             for url in output_images:
-                st.image(url, caption=f"{text_prompt}")
+                st.image(url, caption=f"{text_prompt}", show_download_button=True)
         else:
             st.div()
 
@@ -314,6 +314,8 @@ def get_raw_price(self, state: dict) -> int:
         selected_model = state.get("selected_model")
         match selected_model:
             case InpaintingModels.dall_e.name:
-                return 20
+                unit_price = 20
             case _:
-                return 5
+                unit_price = 5
+
+        return unit_price * state.get("num_outputs", 1)
diff --git a/recipes/QRCodeGenerator.py b/recipes/QRCodeGenerator.py
index 6b7260368..2e3a30002 100644
--- a/recipes/QRCodeGenerator.py
+++ b/recipes/QRCodeGenerator.py
@@ -20,7 +20,7 @@
 )
 from daras_ai_v2.base import BasePage
 from daras_ai_v2.descriptions import prompting101
-from daras_ai_v2.exceptions import raise_for_status
+from daras_ai_v2.exceptions import raise_for_status, UserError
 from daras_ai_v2.img_model_settings_widgets import (
     output_resolution_setting,
     img_model_settings,
@@ -88,18 +88,18 @@ class RequestModel(BaseModel):
         text_prompt: str
         negative_prompt: str | None
         image_prompt: str | None
-        image_prompt_controlnet_models: list[
-            typing.Literal[tuple(e.name for e in ControlNetModels)], ...
-        ] | None
+        image_prompt_controlnet_models: (
+            list[typing.Literal[tuple(e.name for e in ControlNetModels)], ...] | None
+        )
         image_prompt_strength: float | None
         image_prompt_scale: float | None
         image_prompt_pos_x: float | None
         image_prompt_pos_y: float | None
 
         selected_model: typing.Literal[tuple(e.name for e in Text2ImgModels)] | None
-        selected_controlnet_model: list[
-            typing.Literal[tuple(e.name for e in ControlNetModels)], ...
-        ] | None
+        selected_controlnet_model: (
+            list[typing.Literal[tuple(e.name for e in ControlNetModels)], ...] | None
+        )
 
         output_width: int | None
         output_height: int | None
@@ -141,10 +141,19 @@ def related_workflows(self) -> list:
             EmailFaceInpaintingPage,
         ]
 
+    @classmethod
+    def get_example_preferred_fields(cls, state: dict) -> list[str]:
+        if state.get("qr_code_file"):
+            return ["qr_code_file"]
+        elif state.get("qr_code_input_image"):
+            return ["qr_code_input_image"]
+        else:
+            return ["qr_code_data"]
+
     def render_form_v2(self):
         st.text_area(
             """
-            ##### 👩‍💻 Prompt
+            #### 👩‍💻 Prompt
             Describe the subject/scene of the QR Code.
             Choose clear prompts and distinguishable visuals to ensure optimal readability.
             """,
@@ -208,7 +217,7 @@ def render_form_v2(self):
 
         st.file_uploader(
             """
-            ##### 🏞️ Reference Image *[optional]*
+            #### 🏞️ Reference Image *[optional]*
             This image will be used as inspiration to blend with the QR Code.
             """,
             key="image_prompt",
@@ -436,7 +445,7 @@ def _render_outputs(self, state: dict, max_count: int | None = None):
         if max_count:
             output_images = output_images[:max_count]
         for img in output_images:
-            st.image(img)
+            st.image(img, show_download_button=True)
             qr_code_data = (
                 state.get(QrSources.qr_code_data.name)
                 or state.get(QrSources.qr_code_input_image.name)
@@ -566,20 +575,9 @@ def vcard_form(*, key: str) -> VCARD:
             st.error("No contact info found for that email")
         else:
             vcard = imported_vcard
-            # clear inputs
-            st.js(
-                # language=js
-                """
-                const form = document.getElementById("gooey-form");
-                if (!form) return;
-                Object.entries(fields).forEach(([k, v]) => {
-                    const field = form["__vcard_data__" + k];
-                    if (!field) return;
-                    field.value = v;
-                });
-                """,
-                fields=vcard.dict(),
-            )
+            # update inputs
+            for k, v in vcard.dict().items():
+                st.session_state[f"__vcard_data__{k}"] = v
 
     vcard.format_name = st.text_input(
         "Name*",
@@ -698,7 +696,7 @@ def generate_and_upload_qr_code(
         if isinstance(qr_code_data, str):
             qr_code_data = qr_code_data.strip()
         if not qr_code_data:
-            raise ValueError("Please provide QR Code URL, text content, or an image")
+            raise UserError("Please provide QR Code URL, text content, or an image")
         using_shortened_url = request.use_url_shortener and is_url(qr_code_data)
         if using_shortened_url:
             qr_code_data = ShortenedURL.objects.get_or_create_for_workflow(
@@ -746,7 +744,7 @@ def extract_qr_code_data(img: np.ndarray) -> str:
     return info
 
 
-class InvalidQRCode(AssertionError):
+class InvalidQRCode(UserError):
     pass
 
 
diff --git a/recipes/SEOSummary.py b/recipes/SEOSummary.py
index a82424ae1..79d8092a8 100644
--- a/recipes/SEOSummary.py
+++ b/recipes/SEOSummary.py
@@ -98,9 +98,9 @@ class RequestModel(GoogleSearchMixin, BaseModel):
 
         enable_html: bool | None
 
-        selected_model: typing.Literal[
-            tuple(e.name for e in LargeLanguageModels)
-        ] | None
+        selected_model: (
+            typing.Literal[tuple(e.name for e in LargeLanguageModels)] | None
+        )
         sampling_temperature: float | None
         max_tokens: int | None
         num_outputs: int | None
@@ -160,7 +160,7 @@ def render_description(self):
         )
 
     def render_form_v2(self):
-        st.write("### Inputs")
+        st.write("#### Inputs")
         st.text_input("Google Search Query", key="search_query")
         st.text_input("Website Name", key="title")
         st.text_input("Website URL", key="company_url")
@@ -192,7 +192,7 @@ def render_settings(self):
     def render_output(self):
         output_content = st.session_state.get("output_content")
         if output_content:
-            st.write("### Generated Content")
+            st.write("#### Generated Content")
             for idx, text in enumerate(output_content):
                 if st.session_state.get("enable_html"):
                     scrollable_html(text)
diff --git a/recipes/SmartGPT.py b/recipes/SmartGPT.py
index 554a74940..0aabcfefb 100644
--- a/recipes/SmartGPT.py
+++ b/recipes/SmartGPT.py
@@ -34,9 +34,9 @@ class RequestModel(BaseModel):
         reflexion_prompt: str | None
         dera_prompt: str | None
 
-        selected_model: typing.Literal[
-            tuple(e.name for e in LargeLanguageModels)
-        ] | None
+        selected_model: (
+            typing.Literal[tuple(e.name for e in LargeLanguageModels)] | None
+        )
         avoid_repetition: bool | None
         num_outputs: int | None
         quality: float | None
diff --git a/recipes/SocialLookupEmail.py b/recipes/SocialLookupEmail.py
index 082fdcdaa..b2518b1c8 100644
--- a/recipes/SocialLookupEmail.py
+++ b/recipes/SocialLookupEmail.py
@@ -40,9 +40,9 @@ class RequestModel(BaseModel):
         domain: str | None
         key_words: str | None
 
-        selected_model: typing.Literal[
-            tuple(e.name for e in LargeLanguageModels)
-        ] | None
+        selected_model: (
+            typing.Literal[tuple(e.name for e in LargeLanguageModels)] | None
+        )
         sampling_temperature: float | None
         max_tokens: int | None
 
@@ -120,7 +120,7 @@ def render_settings(self):
     def render_form_v2(self):
         st.text_input(
             """
-            ### Email Address
+            #### Email Address
             Give us an email address and we'll try to get determine the profile data associated with it
             """,
             key="email_address",
@@ -132,7 +132,7 @@ def render_form_v2(self):
 
         st.text_area(
             """
-            ### Email Body
+            #### Email Body
             """,
             key="input_email_body",
             height=200,
@@ -198,7 +198,7 @@ def _input_variables(self, state: dict):
     def render_output(self):
         st.text_area(
             """
-            ### Email Body Output 
+            #### Email Body Output 
             """,
             disabled=True,
             value=st.session_state.get("output_email_body", ""),
diff --git a/recipes/Text2Audio.py b/recipes/Text2Audio.py
index 77776ddf5..f7ddf5aab 100644
--- a/recipes/Text2Audio.py
+++ b/recipes/Text2Audio.py
@@ -49,9 +49,9 @@ class RequestModel(BaseModel):
         seed: int | None
         sd_2_upscaling: bool | None
 
-        selected_models: list[
-            typing.Literal[tuple(e.name for e in Text2AudioModels)]
-        ] | None
+        selected_models: (
+            list[typing.Literal[tuple(e.name for e in Text2AudioModels)]] | None
+        )
 
     class ResponseModel(BaseModel):
         output_audios: dict[
@@ -64,7 +64,7 @@ def preview_image(self, state: dict) -> str | None:
     def render_form_v2(self):
         st.text_area(
             """
-            ### 👩‍💻 Prompt
+            #### 👩‍💻 Prompt
             Describe the audio that you'd like to generate.
             """,
             key="text_prompt",
@@ -114,9 +114,9 @@ def run(self, state: dict) -> typing.Iterator[str | None]:
                 ),
                 inputs=dict(
                     prompt=[request.text_prompt],
-                    negative_prompt=[request.negative_prompt]
-                    if request.negative_prompt
-                    else None,
+                    negative_prompt=(
+                        [request.negative_prompt] if request.negative_prompt else None
+                    ),
                     num_waveforms_per_prompt=request.num_outputs,
                     num_inference_steps=request.quality,
                     guidance_scale=request.guidance_scale,
@@ -146,4 +146,6 @@ def _render_output(state):
     for key in selected_models:
         output: dict = state.get("output_audios", {}).get(key, [])
         for audio in output:
-            st.audio(audio, caption=Text2AudioModels[key].value)
+            st.audio(
+                audio, caption=Text2AudioModels[key].value, show_download_button=True
+            )
diff --git a/recipes/TextToSpeech.py b/recipes/TextToSpeech.py
index c37a8eb5f..7d8f301fe 100644
--- a/recipes/TextToSpeech.py
+++ b/recipes/TextToSpeech.py
@@ -12,7 +12,7 @@
 from daras_ai.image_input import upload_file_from_bytes, storage_blob_for
 from daras_ai_v2 import settings
 from daras_ai_v2.base import BasePage
-from daras_ai_v2.exceptions import raise_for_status
+from daras_ai_v2.exceptions import raise_for_status, UserError
 from daras_ai_v2.gpu_server import GpuEndpoints, call_celery_task_outfile
 from daras_ai_v2.loom_video_widget import youtube_video
 from daras_ai_v2.text_to_speech_settings_widgets import (
@@ -53,9 +53,9 @@ class TextToSpeechPage(BasePage):
     class RequestModel(BaseModel):
         text_prompt: str
 
-        tts_provider: typing.Literal[
-            tuple(e.name for e in TextToSpeechProviders)
-        ] | None
+        tts_provider: (
+            typing.Literal[tuple(e.name for e in TextToSpeechProviders)] | None
+        )
 
         uberduck_voice_name: str | None
         uberduck_speaking_rate: float | None
@@ -81,6 +81,10 @@ class ResponseModel(BaseModel):
     def fallback_preivew_image(self) -> str | None:
         return DEFAULT_TTS_META_IMG
 
+    @classmethod
+    def get_example_preferred_fields(cls, state: dict) -> list[str]:
+        return ["tts_provider"]
+
     def preview_description(self, state: dict) -> str:
         return "Input your text, pick a voice & a Text-to-Speech AI engine to create audio. Compare the best voice generators from Google, UberDuck.ai & more to add automated voices to your podcast, YouTube videos, website, or app."
 
@@ -100,7 +104,7 @@ def render_description(self):
     def render_form_v2(self):
         st.text_area(
             """
-            ### Prompt
+            #### Prompt
             Enter text you want to convert to speech
             """,
             key="text_prompt",
@@ -131,12 +135,8 @@ def render_usage_guide(self):
         # loom_video("2d853b7442874b9cbbf3f27b98594add")
 
     def render_output(self):
-        text_prompt = st.session_state.get("text_prompt", "")
         audio_url = st.session_state.get("audio_url")
-        if audio_url:
-            st.audio(audio_url)
-        else:
-            st.div()
+        st.audio(audio_url, show_download_button=True)
 
     def _get_elevenlabs_price(self, state: dict):
         _, is_user_provided_key = self._get_elevenlabs_api_key(state)
@@ -258,13 +258,16 @@ def run(self, state: dict):
 
             case TextToSpeechProviders.ELEVEN_LABS:
                 xi_api_key, is_custom_key = self._get_elevenlabs_api_key(state)
-                assert (
+                if not (
                     is_custom_key
                     or self.is_current_user_paying()
                     or self.is_current_user_admin()
-                ), """
-                    Please purchase Gooey.AI credits to use ElevenLabs voices <a href="/account">here</a>.
-                    """
+                ):
+                    raise UserError(
+                        """
+                        Please purchase Gooey.AI credits to use ElevenLabs voices <a href="/account">here</a>.
+                        """
+                    )
 
                 voice_model = self._get_elevenlabs_voice_model(state)
                 voice_id = self._get_elevenlabs_voice_id(state)
diff --git a/recipes/VideoBots.py b/recipes/VideoBots.py
index 727566611..03cfad8f7 100644
--- a/recipes/VideoBots.py
+++ b/recipes/VideoBots.py
@@ -4,7 +4,7 @@
 import os.path
 import typing
 
-from django.db.models import QuerySet
+from django.db.models import QuerySet, Q
 from furl import furl
 from pydantic import BaseModel, Field
 
@@ -32,6 +32,8 @@
     document_uploader,
 )
 from daras_ai_v2.enum_selector_widget import enum_multiselect
+from daras_ai_v2.exceptions import UserError
+from daras_ai_v2.field_render import field_title_desc
 from daras_ai_v2.enum_selector_widget import enum_selector
 from daras_ai_v2.field_render import field_title_desc, field_desc
 from daras_ai_v2.functions import LLMTools
@@ -630,11 +632,13 @@ def get_raw_price(self, state: dict):
                     "raw_tts_text", state.get("raw_output_text", [])
                 )
                 tts_state = {"text_prompt": "".join(output_text_list)}
-                return super().get_raw_price(state) + TextToSpeechPage().get_raw_price(
+                total = super().get_raw_price(state) + TextToSpeechPage().get_raw_price(
                     tts_state
                 )
             case _:
-                return super().get_raw_price(state)
+                total = super().get_raw_price(state)
+
+        return total * state.get("num_outputs", 1)
 
     def additional_notes(self):
         tts_provider = st.session_state.get("tts_provider")
@@ -650,12 +654,18 @@ def additional_notes(self):
     def run(self, state: dict) -> typing.Iterator[str | None]:
         request: VideoBotsPage.RequestModel = self.RequestModel.parse_obj(state)
 
-        if state.get("tts_provider") == TextToSpeechProviders.ELEVEN_LABS.name:
-            assert (
-                self.is_current_user_paying() or self.is_current_user_admin()
-            ), """
+        if state.get("tts_provider") == TextToSpeechProviders.ELEVEN_LABS.name and not (
+            self.is_current_user_paying() or self.is_current_user_admin()
+        ):
+            raise UserError(
+                """
                 Please purchase Gooey.AI credits to use ElevenLabs voices <a href="/account">here</a>.
                 """
+            )
+
+        state.update(
+            dict(final_prompt=[], output_text=[], output_audio=[], output_video=[])
+        )
 
         user_input = request.input_prompt.strip()
         if not (user_input or request.input_images or request.input_documents):
@@ -743,7 +753,7 @@ def run(self, state: dict) -> typing.Iterator[str | None]:
 
             query_instructions = (request.query_instructions or "").strip()
             if query_instructions:
-                yield "Generating search query..."
+                yield "Creating search query..."
                 state["final_search_query"] = generate_final_search_query(
                     request=request,
                     instructions=query_instructions,
@@ -757,7 +767,7 @@ def run(self, state: dict) -> typing.Iterator[str | None]:
 
             keyword_instructions = (request.keyword_instructions or "").strip()
             if keyword_instructions:
-                yield "Extracting keywords..."
+                yield "Finding keywords..."
                 k_request = request.copy()
                 # other models dont support JSON mode
                 k_request.selected_model = LargeLanguageModels.gpt_4_turbo.name
@@ -837,9 +847,9 @@ def run(self, state: dict) -> typing.Iterator[str | None]:
         )
         max_allowed_tokens = min(max_allowed_tokens, request.max_tokens)
         if max_allowed_tokens < 0:
-            raise ValueError("Input Script is too long! Please reduce the script size.")
+            raise UserError("Input Script is too long! Please reduce the script size.")
 
-        yield f"Running {model.value}..."
+        yield f"Summarizing with {model.value}..."
         if is_chat_model:
             chunks = run_language_model(
                 model=request.selected_model,
@@ -872,15 +882,16 @@ def run(self, state: dict) -> typing.Iterator[str | None]:
         citation_style = (
             request.citation_style and CitationStyles[request.citation_style]
         ) or None
-        all_refs_list = []
-        for i, output_text in enumerate(chunks):
+        for i, entries in enumerate(chunks):
+            if not entries:
+                continue
+            output_text = [entry["content"] for entry in entries]
             if request.tools:
-                output_text, tool_call_choices = output_text
+                # output_text, tool_call_choices = output_text
                 state["output_documents"] = output_documents = []
-                for tool_calls in tool_call_choices:
-                    for call in tool_calls:
-                        result = yield from exec_tool_call(call)
-                        output_documents.append(result)
+                for call in entries[0].get("tool_calls") or []:
+                    result = yield from exec_tool_call(call)
+                    output_documents.append(result)
 
             # save model response
             state["raw_output_text"] = [
@@ -906,15 +917,19 @@ def run(self, state: dict) -> typing.Iterator[str | None]:
                 all_refs_list = apply_response_formattings_prefix(
                     output_text, references, citation_style
                 )
-            state["output_text"] = output_text
-            yield f"Streaming{str(i + 1).translate(SUPERSCRIPT)} {model.value}..."
+            else:
+                all_refs_list = None
 
-        if all_refs_list:
-            apply_response_formattings_suffix(
-                all_refs_list, state["output_text"], citation_style
-            )
-        state["output_audio"] = []
-        state["output_video"] = []
+            state["output_text"] = output_text
+            if all(entry.get("finish_reason") for entry in entries):
+                if all_refs_list:
+                    apply_response_formattings_suffix(
+                        all_refs_list, state["output_text"], citation_style
+                    )
+                finish_reason = entries[0]["finish_reason"]
+                yield f"Completed with {finish_reason=}"  # avoid changing this message since it's used to detect end of stream
+            else:
+                yield f"Streaming{str(i + 1).translate(SUPERSCRIPT)} {model.value}..."
 
         if not request.tts_provider:
             return
@@ -994,11 +1009,11 @@ def render_selected_tab(self, selected_tab):
                     unsafe_allow_html=True,
                 )
 
-            st.write("---")
-            st.text_input(
-                "###### 🤖 [Landbot](https://landbot.io/) URL", key="landbot_url"
-            )
-            show_landbot_widget()
+            # st.write("---")
+            # st.text_input(
+            #     "###### 🤖 [Landbot](https://landbot.io/) URL", key="landbot_url"
+            # )
+            # show_landbot_widget()
 
     def messenger_bot_integration(self):
         from routers.facebook_api import ig_connect_url, fb_connect_url
@@ -1047,15 +1062,28 @@ def messenger_bot_integration(self):
 
         st.button("🔄 Refresh")
 
+        current_run, published_run = self.get_runs_from_query_params(
+            *extract_query_params(gooey_get_query_params())
+        )  # type: ignore
+
+        integrations_q = Q(billing_account_uid=self.request.user.uid)
+
+        # show admins all the bots connected to the current run
+        if self.is_current_user_admin():
+            integrations_q |= Q(saved_run=current_run)
+            if published_run:
+                integrations_q |= Q(
+                    saved_run__example_id=published_run.published_run_id
+                )
+                integrations_q |= Q(published_run=published_run)
+
         integrations: QuerySet[BotIntegration] = BotIntegration.objects.filter(
-            billing_account_uid=self.request.user.uid
+            integrations_q
         ).order_by("platform", "-created_at")
+
         if not integrations:
             return
 
-        current_run, published_run = self.get_runs_from_query_params(
-            *extract_query_params(gooey_get_query_params())
-        )
         for bi in integrations:
             is_connected = (bi.saved_run == current_run) or (
                 (
@@ -1072,14 +1100,27 @@ def messenger_bot_integration(self):
             col1, col2, col3, *_ = st.columns([1, 1, 2])
             with col1:
                 favicon = Platform(bi.platform).get_favicon()
+                if bi.published_run:
+                    url = self.app_url(
+                        example_id=bi.published_run.published_run_id,
+                        tab_name=MenuTabs.paths[MenuTabs.integrations],
+                    )
+                elif bi.saved_run:
+                    url = self.app_url(
+                        run_id=bi.saved_run.run_id,
+                        uid=bi.saved_run.uid,
+                        example_id=bi.saved_run.example_id,
+                        tab_name=MenuTabs.paths[MenuTabs.integrations],
+                    )
+                else:
+                    url = None
+                if url:
+                    href = f'<a href="{url}">{bi}</a>'
+                else:
+                    href = f"<span>{bi}</span>"
                 with st.div(className="mt-2"):
                     st.markdown(
-                        (
-                            f'<img height="20" width="20" src={favicon!r}>&nbsp;&nbsp;'
-                            f'<a href="{bi.saved_run.get_app_url()}">{bi}</a>'
-                            if bi.saved_run
-                            else f"<span>{bi}</span>"
-                        ),
+                        f'<img height="20" width="20" src={favicon!r}>&nbsp;&nbsp;{href}',
                         unsafe_allow_html=True,
                     )
             with col2:
@@ -1114,7 +1155,10 @@ def messenger_bot_integration(self):
                     st.session_state.get("user_language") or bi.user_language
                 )
                 bi.saved_run = current_run
-                bi.published_run = published_run
+                if published_run and published_run.saved_run_id == current_run.id:
+                    bi.published_run = published_run
+                else:
+                    bi.published_run = None
                 if bi.platform == Platform.SLACK:
                     from daras_ai_v2.slack_bot import send_confirmation_msg
 
@@ -1153,6 +1197,7 @@ def slack_specific_settings(self, bi: BotIntegration):
             value=bi.name,
             key=f"_bi_name_{bi.id}",
         )
+        st.caption("Enable streaming messages to Slack in real-time.")
 
 
 def show_landbot_widget():
diff --git a/recipes/VideoBotsStats.py b/recipes/VideoBotsStats.py
index c94b847f2..4781d4b40 100644
--- a/recipes/VideoBotsStats.py
+++ b/recipes/VideoBotsStats.py
@@ -1,3 +1,5 @@
+from django.utils import timezone
+
 from daras_ai_v2.base import BasePage, MenuTabs
 import gooey_ui as st
 from furl import furl
@@ -31,7 +33,7 @@
     TruncYear,
     Concat,
 )
-from django.db.models import Count
+from django.db.models import Count, Avg, Q
 
 ID_COLUMNS = [
     "conversation__fb_page_id",
@@ -119,6 +121,7 @@ def render(self):
         if int(bid) not in allowed_bids:
             bid = allowed_bids[0]
         bi = BotIntegration.objects.get(id=bid)
+        has_analysis_run = bi.analysis_run is not None
         run_title, run_url = self.parse_run_info(bi)
 
         self.show_title_breadcrumb_share(run_title, run_url, bi)
@@ -136,7 +139,7 @@ def render(self):
                 view,
                 factor,
                 trunc_fn,
-            ) = self.render_date_view_inputs()
+            ) = self.render_date_view_inputs(bi)
 
         df = self.calculate_stats_binned_by_time(
             bi, start_date, end_date, factor, trunc_fn
@@ -153,18 +156,26 @@ def render(self):
         st.session_state.setdefault("details", self.request.query_params.get("details"))
         details = st.horizontal_radio(
             "### Details",
-            options=[
-                "All Conversations",
-                "All Messages",
-                "Feedback Positive",
-                "Feedback Negative",
-                "Answered Successfully",
-                "Answered Unsuccessfully",
-            ],
+            options=(
+                [
+                    "Conversations",
+                    "Messages",
+                    "Feedback Positive",
+                    "Feedback Negative",
+                ]
+                + (
+                    [
+                        "Answered Successfully",
+                        "Answered Unsuccessfully",
+                    ]
+                    if has_analysis_run
+                    else []
+                )
+            ),
             key="details",
         )
 
-        if details == "All Conversations":
+        if details == "Conversations":
             options = [
                 "Messages",
                 "Correct Answers",
@@ -210,7 +221,15 @@ def render(self):
             sort_by = st.session_state["sort_by"]
 
         df = self.get_tabular_data(
-            bi, run_url, conversations, messages, details, sort_by, rows=500
+            bi,
+            run_url,
+            conversations,
+            messages,
+            details,
+            sort_by,
+            rows=500,
+            start_date=start_date,
+            end_date=end_date,
         )
 
         if not df.empty:
@@ -233,7 +252,14 @@ def render(self):
             st.html("<br/>")
             if st.checkbox("Export"):
                 df = self.get_tabular_data(
-                    bi, run_url, conversations, messages, details, sort_by
+                    bi,
+                    run_url,
+                    conversations,
+                    messages,
+                    details,
+                    sort_by,
+                    start_date=start_date,
+                    end_date=end_date,
                 )
                 csv = df.to_csv()
                 b64 = base64.b64encode(csv.encode()).decode()
@@ -260,27 +286,35 @@ def render(self):
         ).tostr()
         st.change_url(new_url, self.request)
 
-    def render_date_view_inputs(self):
-        start_of_year_date = datetime.now().replace(month=1, day=1)
-        st.session_state.setdefault(
-            "start_date",
-            self.request.query_params.get(
-                "start_date", start_of_year_date.strftime("%Y-%m-%d")
-            ),
-        )
-        start_date: datetime = (
-            st.date_input("Start date", key="start_date") or start_of_year_date
-        )
-        st.session_state.setdefault(
-            "end_date",
-            self.request.query_params.get(
-                "end_date", datetime.now().strftime("%Y-%m-%d")
-            ),
-        )
-        end_date: datetime = st.date_input("End date", key="end_date") or datetime.now()
-        st.session_state.setdefault(
-            "view", self.request.query_params.get("view", "Weekly")
-        )
+    def render_date_view_inputs(self, bi):
+        if st.checkbox("Show All"):
+            start_date = bi.created_at
+            end_date = timezone.now()
+        else:
+            fifteen_days_ago = timezone.now() - timedelta(days=15)
+            fifteen_days_ago = fifteen_days_ago.replace(hour=0, minute=0, second=0)
+            st.session_state.setdefault(
+                "start_date",
+                self.request.query_params.get(
+                    "start_date", fifteen_days_ago.strftime("%Y-%m-%d")
+                ),
+            )
+            start_date: datetime = (
+                st.date_input("Start date", key="start_date") or fifteen_days_ago
+            )
+            st.session_state.setdefault(
+                "end_date",
+                self.request.query_params.get(
+                    "end_date", timezone.now().strftime("%Y-%m-%d")
+                ),
+            )
+            end_date: datetime = (
+                st.date_input("End date", key="end_date") or timezone.now()
+            )
+            st.session_state.setdefault(
+                "view", self.request.query_params.get("view", "Daily")
+            )
+        st.write("---")
         view = st.horizontal_radio(
             "### View",
             options=["Daily", "Weekly", "Monthly"],
@@ -307,15 +341,12 @@ def render_date_view_inputs(self):
 
     def parse_run_info(self, bi):
         saved_run = bi.get_active_saved_run()
-        run_title = (
-            bi.published_run.title
-            if bi.published_run
-            else saved_run.page_title
-            if saved_run and saved_run.page_title
-            else "This Copilot Run"
-            if saved_run
-            else "No Run Connected"
-        )
+        if bi.published_run:
+            run_title = bi.published_run.title
+        elif saved_run:
+            run_title = "This Copilot Run"
+        else:
+            run_title = "No Run Connected"
         run_url = furl(saved_run.get_app_url()).tostr() if saved_run else ""
         return run_title, run_url
 
@@ -331,7 +362,7 @@ def calculate_overall_stats(self, bid, bi, run_title, run_url):
         num_active_users_last_7_days = (
             user_messages.filter(
                 conversation__in=users,
-                created_at__gte=datetime.now() - timedelta(days=7),
+                created_at__gte=timezone.now() - timedelta(days=7),
             )
             .distinct(
                 *ID_COLUMNS,
@@ -341,7 +372,7 @@ def calculate_overall_stats(self, bid, bi, run_title, run_url):
         num_active_users_last_30_days = (
             user_messages.filter(
                 conversation__in=users,
-                created_at__gte=datetime.now() - timedelta(days=30),
+                created_at__gte=timezone.now() - timedelta(days=30),
             )
             .distinct(
                 *ID_COLUMNS,
@@ -393,7 +424,7 @@ def calculate_stats_binned_by_time(
                 created_at__date__gte=start_date,
                 created_at__date__lte=end_date,
                 conversation__bot_integration=bi,
-                role=CHATML_ROLE_USER,
+                role=CHATML_ROLE_ASSISTANT,
             )
             .order_by()
             .annotate(date=trunc_fn("created_at"))
@@ -408,6 +439,7 @@ def calculate_stats_binned_by_time(
                     distinct=True,
                 )
             )
+            .annotate(Average_runtime=Avg("saved_run__run_time"))
             .annotate(Unique_feedback_givers=Count("feedbacks", distinct=True))
             .values(
                 "date",
@@ -415,6 +447,7 @@ def calculate_stats_binned_by_time(
                 "Convos",
                 "Senders",
                 "Unique_feedback_givers",
+                "Average_runtime",
             )
         )
 
@@ -446,6 +479,20 @@ def calculate_stats_binned_by_time(
             .values("date", "Neg_feedback")
         )
 
+        successfully_answered = (
+            Message.objects.filter(
+                conversation__bot_integration=bi,
+                analysis_result__contains={"Answered": True},
+                created_at__date__gte=start_date,
+                created_at__date__lte=end_date,
+            )
+            .order_by()
+            .annotate(date=trunc_fn("created_at"))
+            .values("date")
+            .annotate(Successfully_Answered=Count("id"))
+            .values("date", "Successfully_Answered")
+        )
+
         df = pd.DataFrame(
             messages_received,
             columns=[
@@ -454,6 +501,7 @@ def calculate_stats_binned_by_time(
                 "Convos",
                 "Senders",
                 "Unique_feedback_givers",
+                "Average_runtime",
             ],
         )
         df = df.merge(
@@ -468,16 +516,34 @@ def calculate_stats_binned_by_time(
             left_on="date",
             right_on="date",
         )
+        df = df.merge(
+            pd.DataFrame(
+                successfully_answered, columns=["date", "Successfully_Answered"]
+            ),
+            how="outer",
+            left_on="date",
+            right_on="date",
+        )
         df["Messages_Sent"] = df["Messages_Sent"] * factor
         df["Convos"] = df["Convos"] * factor
         df["Senders"] = df["Senders"] * factor
         df["Unique_feedback_givers"] = df["Unique_feedback_givers"] * factor
         df["Pos_feedback"] = df["Pos_feedback"] * factor
         df["Neg_feedback"] = df["Neg_feedback"] * factor
+        df["Percentage_positive_feedback"] = (
+            df["Pos_feedback"] / df["Messages_Sent"]
+        ) * 100
+        df["Percentage_negative_feedback"] = (
+            df["Neg_feedback"] / df["Messages_Sent"]
+        ) * 100
+        df["Percentage_successfully_answered"] = (
+            df["Successfully_Answered"] / df["Messages_Sent"]
+        ) * 100
         df["Msgs_per_convo"] = df["Messages_Sent"] / df["Convos"]
         df["Msgs_per_user"] = df["Messages_Sent"] / df["Senders"]
         df.fillna(0, inplace=True)
         df = df.round(0).astype("int32", errors="ignore")
+        df = df.sort_values(by=["date"], ascending=True).reset_index()
         return df
 
     def plot_graphs(self, view, df):
@@ -621,14 +687,105 @@ def plot_graphs(self, view, df):
                 ],
             )
         st.plotly_chart(fig)
+        st.write("---")
+        fig = go.Figure(
+            data=[
+                go.Scatter(
+                    name="Average Run Time",
+                    mode="lines+markers",
+                    x=list(df["date"]),
+                    y=list(df["Average_runtime"]),
+                    text=list(df["Average_runtime"]),
+                    hovertemplate="Average Runtime: %{y:.0f}<extra></extra>",
+                ),
+            ],
+            layout=dict(
+                margin=dict(l=0, r=0, t=28, b=0),
+                yaxis=dict(
+                    title="Seconds",
+                ),
+                title=dict(
+                    text=f"{view} Performance Metrics",
+                ),
+                height=300,
+                template="plotly_white",
+            ),
+        )
+        st.plotly_chart(fig)
+        st.write("---")
+        fig = go.Figure(
+            data=[
+                go.Scatter(
+                    name="Positive Feedback",
+                    mode="lines+markers",
+                    x=list(df["date"]),
+                    y=list(df["Percentage_positive_feedback"]),
+                    text=list(df["Percentage_positive_feedback"]),
+                    hovertemplate="Positive Feedback: %{y:.0f}%<extra></extra>",
+                ),
+                go.Scatter(
+                    name="Negative Feedback",
+                    mode="lines+markers",
+                    x=list(df["date"]),
+                    y=list(df["Percentage_negative_feedback"]),
+                    text=list(df["Percentage_negative_feedback"]),
+                    hovertemplate="Negative Feedback: %{y:.0f}%<extra></extra>",
+                ),
+                go.Scatter(
+                    name="Successfully Answered",
+                    mode="lines+markers",
+                    x=list(df["date"]),
+                    y=list(df["Percentage_successfully_answered"]),
+                    text=list(df["Percentage_successfully_answered"]),
+                    hovertemplate="Successfully Answered: %{y:.0f}%<extra></extra>",
+                ),
+            ],
+            layout=dict(
+                margin=dict(l=0, r=0, t=28, b=0),
+                yaxis=dict(
+                    title="Percentage",
+                    range=[0, 100],
+                    tickvals=[
+                        *range(
+                            0,
+                            101,
+                            10,
+                        )
+                    ],
+                ),
+                title=dict(
+                    text=f"{view} Feedback Distribution",
+                ),
+                height=300,
+                template="plotly_white",
+            ),
+        )
+        st.plotly_chart(fig)
 
     def get_tabular_data(
-        self, bi, run_url, conversations, messages, details, sort_by, rows=10000
+        self,
+        bi,
+        run_url,
+        conversations,
+        messages,
+        details,
+        sort_by,
+        rows=10000,
+        start_date=None,
+        end_date=None,
     ):
         df = pd.DataFrame()
-        if details == "All Conversations":
+        if details == "Conversations":
+            if start_date and end_date:
+                conversations = conversations.filter(
+                    created_at__date__gte=start_date, created_at__date__lte=end_date
+                )
             df = conversations.to_df_format(row_limit=rows)
-        elif details == "All Messages":
+        elif details == "Messages":
+            if start_date and end_date:
+                messages = messages.filter(
+                    created_at__date__gte=start_date, created_at__date__lte=end_date
+                )
             df = messages.order_by("-created_at", "conversation__id").to_df_format(
                 row_limit=rows
             )
@@ -639,6 +796,10 @@ def get_tabular_data(
                 message__conversation__bot_integration=bi,
                 rating=Feedback.Rating.RATING_THUMBS_UP,
             )  # type: ignore
+            if start_date and end_date:
+                pos_feedbacks = pos_feedbacks.filter(
+                    created_at__date__gte=start_date, created_at__date__lte=end_date
+                )
             df = pos_feedbacks.to_df_format(row_limit=rows)
             df["Run URL"] = run_url
             df["Bot"] = bi.name
@@ -647,27 +808,41 @@ def get_tabular_data(
                 message__conversation__bot_integration=bi,
                 rating=Feedback.Rating.RATING_THUMBS_DOWN,
             )  # type: ignore
+            if start_date and end_date:
+                neg_feedbacks = neg_feedbacks.filter(
+                    created_at__date__gte=start_date, created_at__date__lte=end_date
+                )
             df = neg_feedbacks.to_df_format(row_limit=rows)
             df["Run URL"] = run_url
             df["Bot"] = bi.name
         elif details == "Answered Successfully":
             successful_messages: MessageQuerySet = Message.objects.filter(
+                Q(analysis_result__contains={"Answered": True})
+                | Q(analysis_result__contains={"assistant": {"answer": "Found"}}),
                 conversation__bot_integration=bi,
-                analysis_result__contains={"Answered": True},
             )  # type: ignore
+            if start_date and end_date:
+                successful_messages = successful_messages.filter(
+                    created_at__date__gte=start_date, created_at__date__lte=end_date
+                )
             df = successful_messages.to_df_analysis_format(row_limit=rows)
             df["Run URL"] = run_url
             df["Bot"] = bi.name
         elif details == "Answered Unsuccessfully":
             unsuccessful_messages: MessageQuerySet = Message.objects.filter(
+                Q(analysis_result__contains={"Answered": False})
+                | Q(analysis_result__contains={"assistant": {"answer": "Missing"}}),
                 conversation__bot_integration=bi,
-                analysis_result__contains={"Answered": False},
             )  # type: ignore
+            if start_date and end_date:
+                unsuccessful_messages = unsuccessful_messages.filter(
+                    created_at__date__gte=start_date, created_at__date__lte=end_date
+                )
             df = unsuccessful_messages.to_df_analysis_format(row_limit=rows)
             df["Run URL"] = run_url
             df["Bot"] = bi.name
 
-        if sort_by:
+        if sort_by and sort_by in df.columns:
             df.sort_values(by=[sort_by], ascending=False, inplace=True)
 
         return df
diff --git a/recipes/asr.py b/recipes/asr.py
index a297bf9c3..3542614c8 100644
--- a/recipes/asr.py
+++ b/recipes/asr.py
@@ -48,6 +48,10 @@ class ResponseModel(BaseModel):
         raw_output_text: list[str] | None
         output_text: list[str | AsrOutputJson]
 
+    @classmethod
+    def get_example_preferred_fields(cls, state: dict) -> list[str]:
+        return ["selected_model", "language", "google_translate_target"]
+
     def preview_image(self, state: dict) -> str | None:
         return DEFAULT_ASR_META_IMG
 
@@ -82,14 +86,14 @@ def related_workflows(self) -> list:
 
     def render_form_v2(self):
         document_uploader(
-            "##### Audio Files",
+            "#### Audio Files",
             accept=("audio/*", "video/*", "application/octet-stream"),
         )
         col1, col2 = st.columns(2, responsive=False)
         with col1:
             selected_model = enum_selector(
                 AsrModels,
-                label="##### ASR Model",
+                label="#### ASR Model",
                 key="selected_model",
                 use_selectbox=True,
             )
diff --git a/routers/api.py b/routers/api.py
index c57d948a6..bc9a0303e 100644
--- a/routers/api.py
+++ b/routers/api.py
@@ -30,6 +30,7 @@
     BasePage,
     StateKeys,
 )
+from gooeysite.bg_db_conn import get_celery_result_db_safe
 
 app = APIRouter()
 
@@ -352,7 +353,7 @@ def submit_api_call(
             },
         )
     # create a new run
-    example_id, run_id, uid = self.create_new_run()
+    example_id, run_id, uid = self.create_new_run(is_api_call=True)
     # submit the task
     result = self.call_runner_task(example_id, run_id, uid, is_api_call=True)
     return self, result, run_id, uid
@@ -367,7 +368,7 @@ def build_api_response(
     run_async: bool,
     created_at: str,
 ):
-    web_url = str(furl(self.app_url(run_id=run_id, uid=uid)))
+    web_url = self.app_url(run_id=run_id, uid=uid)
     if run_async:
         status_url = str(
             furl(settings.API_BASE_URL, query_params=dict(run_id=run_id))
@@ -383,7 +384,7 @@ def build_api_response(
         }
     else:
         # wait for the result
-        result.get(disable_sync_subtasks=False)
+        get_celery_result_db_safe(result)
         state = self.run_doc_sr(run_id, uid).to_dict()
         # check for errors
         err_msg = state.get(StateKeys.error_msg)
diff --git a/routers/billing.py b/routers/billing.py
index 5f2f2cb06..39dfa61fb 100644
--- a/routers/billing.py
+++ b/routers/billing.py
@@ -114,12 +114,14 @@ def account(request: Request):
     is_admin = request.user.email in settings.ADMIN_EMAILS
 
     context = {
+        "title": "Account • Gooey.AI",
         "request": request,
         "settings": settings,
         "available_subscriptions": available_subscriptions,
         "user_credits": request.user.balance,
         "subscription": get_user_subscription(request.user),
         "is_admin": is_admin,
+        "canonical_url": account_url,
     }
 
     return templates.TemplateResponse("account.html", context)
diff --git a/routers/facebook_api.py b/routers/facebook_api.py
index af409c8fd..1f3195f2d 100644
--- a/routers/facebook_api.py
+++ b/routers/facebook_api.py
@@ -34,7 +34,9 @@ def fb_connect_redirect(request: Request):
         )
     user_access_token = _get_access_token_from_code(code)
 
-    db.get_user_doc_ref(request.user.uid).update({"fb_access_token": user_access_token})
+    db.get_user_doc_ref(request.user.uid).set(
+        {"fb_access_token": user_access_token}, merge=True
+    )
 
     fb_pages = get_currently_connected_fb_pages(user_access_token)
     if not fb_pages:
diff --git a/routers/root.py b/routers/root.py
index 6f854ba20..27cb62934 100644
--- a/routers/root.py
+++ b/routers/root.py
@@ -1,6 +1,5 @@
 import datetime
 import os.path
-import subprocess
 import tempfile
 import typing
 from time import time
@@ -27,12 +26,11 @@
 from daras_ai_v2.all_pages import all_api_pages, normalize_slug, page_slug_map
 from daras_ai_v2.api_examples_widget import api_example_generator
 from daras_ai_v2.asr import FFMPEG_WAV_ARGS, check_wav_audio_format
-from daras_ai_v2.base import (
-    RedirectException,
-    get_example_request_body,
-)
+from daras_ai_v2.base import RedirectException
+from daras_ai_v2.bots import request_json
 from daras_ai_v2.copy_to_clipboard_button_widget import copy_to_clipboard_scripts
 from daras_ai_v2.db import FIREBASE_SESSION_COOKIE
+from daras_ai_v2.exceptions import ffmpeg, UserError
 from daras_ai_v2.manage_api_keys_widget import manage_api_keys
 from daras_ai_v2.meta_content import build_meta_tags, raw_build_meta_tags
 from daras_ai_v2.meta_preview_url import meta_preview_url
@@ -165,6 +163,11 @@ async def logout(request: Request):
     return RedirectResponse(request.query_params.get("next", DEFAULT_LOGOUT_REDIRECT))
 
 
+@app.post("/__/file-upload/url/meta")
+async def file_upload(request: Request, body_json: dict = Depends(request_json)):
+    return dict(name=(body_json["url"]), type="url/undefined", size=None)
+
+
 @app.post("/__/file-upload/")
 def file_upload(request: Request, form_data: FormData = Depends(request_form_files)):
     from wand.image import Image
@@ -180,22 +183,16 @@ def file_upload(request: Request, form_data: FormData = Depends(request_form_fil
         ) as infile:
             infile.write(data)
             infile.flush()
-            if not check_wav_audio_format(infile.name):
-                with tempfile.NamedTemporaryFile(suffix=".wav") as outfile:
-                    args = [
-                        "ffmpeg",
-                        "-y",
-                        "-i",
-                        infile.name,
-                        *FFMPEG_WAV_ARGS,
-                        outfile.name,
-                    ]
-                    print("\t$ " + " ".join(args))
-                    subprocess.check_call(args)
-
-                    filename += ".wav"
-                    content_type = "audio/wav"
-                    data = outfile.read()
+            try:
+                if not check_wav_audio_format(infile.name):
+                    with tempfile.NamedTemporaryFile(suffix=".wav") as outfile:
+                        ffmpeg("-i", infile.name, *FFMPEG_WAV_ARGS, outfile.name)
+
+                        filename += ".wav"
+                        content_type = "audio/wav"
+                        data = outfile.read()
+            except UserError as e:
+                return Response(content=str(e), status_code=400)
 
     if content_type.startswith("image/"):
         with Image(blob=data) as img:
@@ -299,9 +296,7 @@ def _api_docs_page(request):
 
     page = workflow.page_cls(request=request)
     state = page.get_root_published_run().saved_run.to_dict()
-    request_body = get_example_request_body(
-        page.RequestModel, state, include_all=include_all
-    )
+    request_body = page.get_example_request_body(state, include_all=include_all)
     response_body = page.get_example_response_body(
         state, as_async=as_async, include_all=include_all
     )
diff --git a/scripts/init_llm_pricing.py b/scripts/init_llm_pricing.py
new file mode 100644
index 000000000..a1f55e964
--- /dev/null
+++ b/scripts/init_llm_pricing.py
@@ -0,0 +1,338 @@
+from daras_ai_v2.language_model import LargeLanguageModels
+from usage_costs.models import ModelSku, ModelCategory, ModelProvider, ModelPricing
+
+
+def run():
+    category = ModelCategory.LLM
+
+    # GPT-4-Turbo
+
+    for model in ["gpt-4-0125-preview", "gpt-4-1106-preview"]:
+        ModelPricing.objects.create(
+            model_id=model,
+            model_name=LargeLanguageModels.gpt_4_turbo.name,
+            sku=ModelSku.llm_prompt,
+            unit_cost=0.01,
+            unit_quantity=1000,
+            category=category,
+            provider=ModelProvider.openai,
+            pricing_url="https://openai.com/pricing",
+        )
+        ModelPricing.objects.create(
+            model_id=model,
+            model_name=LargeLanguageModels.gpt_4_turbo.name,
+            sku=ModelSku.llm_completion,
+            unit_cost=0.03,
+            unit_quantity=1000,
+            category=category,
+            provider=ModelProvider.openai,
+            pricing_url="https://openai.com/pricing",
+        )
+
+    ModelPricing.objects.create(
+        model_id="openai-gpt-4-turbo-prod-ca-1",
+        model_name=LargeLanguageModels.gpt_4_turbo.name,
+        sku=ModelSku.llm_prompt,
+        unit_cost=0.01,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.azure_openai,
+        pricing_url="https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+    )
+    ModelPricing.objects.create(
+        model_id="openai-gpt-4-turbo-prod-ca-1",
+        model_name=LargeLanguageModels.gpt_4_turbo.name,
+        sku=ModelSku.llm_completion,
+        unit_cost=0.03,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.azure_openai,
+        pricing_url="https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+    )
+
+    #  GPT-4-Turbo-Vision
+
+    ModelPricing.objects.create(
+        model_id="gpt-4-vision-preview",
+        model_name=LargeLanguageModels.gpt_4_vision.name,
+        sku=ModelSku.llm_prompt,
+        unit_cost=0.01,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.openai,
+        pricing_url="https://openai.com/pricing",
+    )
+    ModelPricing.objects.create(
+        model_id="gpt-4-vision-preview",
+        model_name=LargeLanguageModels.gpt_4_vision.name,
+        sku=ModelSku.llm_completion,
+        unit_cost=0.03,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.openai,
+        pricing_url="https://openai.com/pricing",
+    )
+
+    ModelPricing.objects.create(
+        model_id="openai-gpt-4-turbo-vision-prod-ca-1",
+        model_name=LargeLanguageModels.gpt_4_vision.name,
+        sku=ModelSku.llm_prompt,
+        unit_cost=0.01,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.azure_openai,
+        pricing_url="https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+    )
+    ModelPricing.objects.create(
+        model_id="openai-gpt-4-turbo-vision-prod-ca-1",
+        model_name=LargeLanguageModels.gpt_4_vision.name,
+        sku=ModelSku.llm_completion,
+        unit_cost=0.03,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.azure_openai,
+        pricing_url="https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+    )
+
+    # GPT-4
+
+    ModelPricing.objects.create(
+        model_id="gpt-4",
+        model_name=LargeLanguageModels.gpt_4.name,
+        sku=ModelSku.llm_prompt,
+        unit_cost=0.03,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.openai,
+        pricing_url="https://openai.com/pricing",
+    )
+    ModelPricing.objects.create(
+        model_id="gpt-4",
+        model_name=LargeLanguageModels.gpt_4.name,
+        sku=ModelSku.llm_completion,
+        unit_cost=0.06,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.openai,
+        pricing_url="https://openai.com/pricing",
+    )
+
+    ModelPricing.objects.create(
+        model_id="openai-gpt-4-prod-ca-1",
+        model_name=LargeLanguageModels.gpt_4.name,
+        sku=ModelSku.llm_prompt,
+        unit_cost=0.03,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.azure_openai,
+        pricing_url="https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+    )
+    ModelPricing.objects.create(
+        model_id="openai-gpt-4-prod-ca-1",
+        model_name=LargeLanguageModels.gpt_4.name,
+        sku=ModelSku.llm_completion,
+        unit_cost=0.06,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.azure_openai,
+        pricing_url="https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+    )
+
+    # GPT-4-32k
+
+    ModelPricing.objects.create(
+        model_id="gpt-4-32k",
+        model_name=LargeLanguageModels.gpt_4_32k.name,
+        sku=ModelSku.llm_prompt,
+        unit_cost=0.06,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.openai,
+        pricing_url="https://openai.com/pricing",
+    )
+    ModelPricing.objects.create(
+        model_id="gpt-4-32k",
+        model_name=LargeLanguageModels.gpt_4_32k.name,
+        sku=ModelSku.llm_completion,
+        unit_cost=0.12,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.openai,
+        pricing_url="https://openai.com/pricing",
+    )
+
+    ModelPricing.objects.create(
+        model_id="openai-gpt-4-32k-prod-ca-1",
+        model_name=LargeLanguageModels.gpt_4_32k.name,
+        sku=ModelSku.llm_prompt,
+        unit_cost=0.06,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.azure_openai,
+        pricing_url="https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+    )
+    ModelPricing.objects.create(
+        model_id="openai-gpt-4-32k-prod-ca-1",
+        model_name=LargeLanguageModels.gpt_4_32k.name,
+        sku=ModelSku.llm_completion,
+        unit_cost=0.12,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.azure_openai,
+        pricing_url="https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+    )
+
+    # GPT-3.5-Turbo
+
+    ModelPricing.objects.create(
+        model_id="gpt-3.5-turbo-0613",
+        model_name=LargeLanguageModels.gpt_3_5_turbo.name,
+        sku=ModelSku.llm_prompt,
+        unit_cost=0.0015,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.openai,
+        pricing_url="https://openai.com/pricing",
+    )
+    ModelPricing.objects.create(
+        model_id="gpt-3.5-turbo-0613",
+        model_name=LargeLanguageModels.gpt_3_5_turbo.name,
+        sku=ModelSku.llm_completion,
+        unit_cost=0.002,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.openai,
+        pricing_url="https://openai.com/pricing",
+    )
+
+    ModelPricing.objects.create(
+        model_id="openai-gpt-35-turbo-prod-ca-1",
+        model_name=LargeLanguageModels.gpt_3_5_turbo.name,
+        sku=ModelSku.llm_prompt,
+        unit_cost=0.0015,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.azure_openai,
+        pricing_url="https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+    )
+    ModelPricing.objects.create(
+        model_id="openai-gpt-35-turbo-prod-ca-1",
+        model_name=LargeLanguageModels.gpt_3_5_turbo.name,
+        sku=ModelSku.llm_completion,
+        unit_cost=0.002,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.azure_openai,
+        pricing_url="https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+    )
+
+    # GPT-3.5-Turbo-16k
+
+    ModelPricing.objects.create(
+        model_id="gpt-3.5-turbo-16k-0613",
+        model_name=LargeLanguageModels.gpt_3_5_turbo_16k.name,
+        sku=ModelSku.llm_prompt,
+        unit_cost=0.003,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.openai,
+        pricing_url="https://openai.com/pricing",
+    )
+    ModelPricing.objects.create(
+        model_id="gpt-3.5-turbo-16k-0613",
+        model_name=LargeLanguageModels.gpt_3_5_turbo_16k.name,
+        sku=ModelSku.llm_completion,
+        unit_cost=0.004,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.openai,
+        pricing_url="https://openai.com/pricing",
+    )
+
+    ModelPricing.objects.create(
+        model_id="openai-gpt-35-turbo-16k-prod-ca-1",
+        model_name=LargeLanguageModels.gpt_3_5_turbo_16k.name,
+        sku=ModelSku.llm_prompt,
+        unit_cost=0.003,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.azure_openai,
+        pricing_url="https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+    )
+    ModelPricing.objects.create(
+        model_id="openai-gpt-35-turbo-16k-prod-ca-1",
+        model_name=LargeLanguageModels.gpt_3_5_turbo_16k.name,
+        sku=ModelSku.llm_completion,
+        unit_cost=0.004,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.azure_openai,
+        pricing_url="https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
+    )
+
+    # Palm2
+
+    ModelPricing.objects.create(
+        model_id="text-bison",
+        model_name=LargeLanguageModels.palm2_text.name,
+        sku=ModelSku.llm_prompt,
+        unit_cost=0.00025,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.google,
+        pricing_url="https://cloud.google.com/vertex-ai/docs/generative-ai/pricing#text_generation",
+    )
+    ModelPricing.objects.create(
+        model_id="text-bison",
+        model_name=LargeLanguageModels.palm2_text.name,
+        sku=ModelSku.llm_completion,
+        unit_cost=0.0005,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.google,
+        pricing_url="https://cloud.google.com/vertex-ai/docs/generative-ai/pricing#text_generation",
+    )
+
+    ModelPricing.objects.create(
+        model_id="chat-bison",
+        model_name=LargeLanguageModels.palm2_chat.name,
+        sku=ModelSku.llm_prompt,
+        unit_cost=0.00025,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.google,
+        pricing_url="https://cloud.google.com/vertex-ai/docs/generative-ai/pricing#text_generation",
+    )
+    ModelPricing.objects.create(
+        model_id="chat-bison",
+        model_name=LargeLanguageModels.palm2_chat.name,
+        sku=ModelSku.llm_completion,
+        unit_cost=0.0005,
+        unit_quantity=1000,
+        category=category,
+        provider=ModelProvider.google,
+        pricing_url="https://cloud.google.com/vertex-ai/docs/generative-ai/pricing#text_generation",
+    )
+
+    # Llama2
+
+    ModelPricing.objects.create(
+        model_id="togethercomputer/llama-2-70b-chat",
+        model_name=LargeLanguageModels.llama2_70b_chat.name,
+        sku=ModelSku.llm_prompt,
+        unit_cost=0.9,
+        unit_quantity=10**6,
+        category=category,
+        provider=ModelProvider.together_ai,
+        pricing_url="https://www.together.ai/pricing",
+    )
+    ModelPricing.objects.create(
+        model_id="togethercomputer/llama-2-70b-chat",
+        model_name=LargeLanguageModels.llama2_70b_chat.name,
+        sku=ModelSku.llm_completion,
+        unit_cost=0.9,
+        unit_quantity=10**6,
+        category=category,
+        provider=ModelProvider.together_ai,
+        pricing_url="https://www.together.ai/pricing",
+    )
diff --git a/scripts/init_self_hosted_pricing.py b/scripts/init_self_hosted_pricing.py
new file mode 100644
index 000000000..d1df62a58
--- /dev/null
+++ b/scripts/init_self_hosted_pricing.py
@@ -0,0 +1,50 @@
+from decimal import Decimal
+
+from daras_ai_v2.gpu_server import build_queue_name
+from daras_ai_v2.stable_diffusion import (
+    Text2ImgModels,
+    Img2ImgModels,
+    InpaintingModels,
+    text2img_model_ids,
+    img2img_model_ids,
+    inpaint_model_ids,
+)
+from recipes.DeforumSD import AnimationModels
+from usage_costs.models import ModelPricing
+from usage_costs.models import ModelSku, ModelCategory, ModelProvider
+
+category = ModelCategory.SELF_HOSTED
+
+
+def run():
+    for model in AnimationModels:
+        add_model(model.value, model.name)
+    for model_enum, model_ids in [
+        (Text2ImgModels, text2img_model_ids),
+        (Img2ImgModels, img2img_model_ids),
+        (InpaintingModels, inpaint_model_ids),
+    ]:
+        for m in model_enum:
+            if "dall_e" in m.name:
+                continue
+            try:
+                add_model(model_ids[m], m.name)
+            except KeyError:
+                pass
+    add_model("wav2lip_gan.pth", "wav2lip")
+
+
+def add_model(model_id, model_name):
+    ModelPricing.objects.get_or_create(
+        model_id=build_queue_name("gooey-gpu", model_id),
+        sku=ModelSku.gpu_ms,
+        defaults=dict(
+            model_name=model_name,
+            unit_cost=Decimal("3.673"),
+            unit_quantity=3600000,
+            category=category,
+            provider=ModelProvider.aks,
+            notes="NC24ads A100 v4 - 1 X A100 - Pay as you go - $3.6730/hour",
+            pricing_url="https://azure.microsoft.com/en-in/pricing/details/virtual-machines/linux/#pricing",
+        ),
+    )
diff --git a/scripts/test_wa_msg_send.py b/scripts/test_wa_msg_send.py
new file mode 100644
index 000000000..c31fca0af
--- /dev/null
+++ b/scripts/test_wa_msg_send.py
@@ -0,0 +1,124 @@
+from time import sleep
+
+from daras_ai_v2.bots import _feedback_start_buttons
+from daras_ai_v2.facebook_bots import WhatsappBot
+
+
+def run(bot_number: str, user_number: str):
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        text="",
+        buttons=_feedback_start_buttons(),
+    )
+    sleep(1)
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        text="",
+    )
+    sleep(1)
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        text="Text With Buttons",
+        buttons=_feedback_start_buttons(),
+    )
+    sleep(1)
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        audio="https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/d949d330-95cb-11ee-9a21-02420a00012e/google_tts_gen.mp3",
+    )
+    sleep(1)
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        audio="https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/d949d330-95cb-11ee-9a21-02420a00012e/google_tts_gen.mp3",
+        buttons=_feedback_start_buttons(),
+    )
+    sleep(1)
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        text="Audio with text",
+        audio="https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/d949d330-95cb-11ee-9a21-02420a00012e/google_tts_gen.mp3",
+        buttons=_feedback_start_buttons(),
+    )
+    sleep(1)
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        text="Audio + Video",
+        audio="https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/d949d330-95cb-11ee-9a21-02420a00012e/google_tts_gen.mp3",
+        video="https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/6f019f2a-b714-11ee-82f3-02420a000172/gooey.ai%20lipsync.mp4#t=0.001",
+        buttons=_feedback_start_buttons(),
+    )
+    sleep(1)
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        video="https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/6f019f2a-b714-11ee-82f3-02420a000172/gooey.ai%20lipsync.mp4#t=0.001",
+    )
+    sleep(1)
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        video="https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/6f019f2a-b714-11ee-82f3-02420a000172/gooey.ai%20lipsync.mp4#t=0.001",
+        buttons=_feedback_start_buttons(),
+    )
+    sleep(1)
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        text="Video with text",
+        video="https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/6f019f2a-b714-11ee-82f3-02420a000172/gooey.ai%20lipsync.mp4#t=0.001",
+        buttons=_feedback_start_buttons(),
+    )
+    sleep(1)
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        documents=[
+            "https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/d30155b8-b438-11ed-85e8-02420a0001f7/Chetan%20Bhagat%20-three%20mistakes%20of%20my%20life.pdf"
+        ],
+    )
+    sleep(1)
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        documents=[
+            "https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/d30155b8-b438-11ed-85e8-02420a0001f7/Chetan%20Bhagat%20-three%20mistakes%20of%20my%20life.pdf"
+        ],
+        buttons=_feedback_start_buttons(),
+    )
+    sleep(1)
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        text="Some Docs",
+        documents=[
+            "https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/d30155b8-b438-11ed-85e8-02420a0001f7/Chetan%20Bhagat%20-three%20mistakes%20of%20my%20life.pdf"
+        ],
+    )
+    sleep(1)
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        text="Some Docs",
+        documents=[
+            "https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/d30155b8-b438-11ed-85e8-02420a0001f7/Chetan%20Bhagat%20-three%20mistakes%20of%20my%20life.pdf"
+        ],
+        buttons=_feedback_start_buttons(),
+    )
+    sleep(1)
+    WhatsappBot.send_msg_to(
+        bot_number=bot_number,
+        user_number=user_number,
+        text="Audio + Docs",
+        audio="https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/d949d330-95cb-11ee-9a21-02420a00012e/google_tts_gen.mp3",
+        documents=[
+            "https://storage.googleapis.com/dara-c1b52.appspot.com/daras_ai/media/d30155b8-b438-11ed-85e8-02420a0001f7/Chetan%20Bhagat%20-three%20mistakes%20of%20my%20life.pdf"
+        ],
+        buttons=_feedback_start_buttons(),
+    )
diff --git a/templates/account.html b/templates/account.html
index 2755facc1..6c14bc501 100644
--- a/templates/account.html
+++ b/templates/account.html
@@ -1,5 +1,11 @@
 {% extends 'base.html' %}
 
+{% block head %}
+<meta name="robots" content="noindex,nofollow">
+<meta name="description" content="Your API keys, profile, and billing details.">
+<link rel="canonical" href="{{ canonical_url }}">
+{% endblock %}
+
 {% block content %}
     <script src="https://js.stripe.com/v3/" async defer></script>
     <script src="https://www.paypal.com/sdk/js?client-id={{ settings.PAYPAL_CLIENT_ID }}&currency=USD&enable-funding=venmo&disable-funding=paylater"
@@ -231,4 +237,4 @@ <h4 id="subscription-text">
             container.innerHTML = message;
         }
     </script>
-{% endblock content %}
\ No newline at end of file
+{% endblock content %}
diff --git a/templates/base.html b/templates/base.html
index e2c180de7..5af87990a 100644
--- a/templates/base.html
+++ b/templates/base.html
@@ -7,7 +7,8 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 
-    <title>{{ title }}</title>
+    <title>{% block title %}{{ title }}{% endblock title %}</title>
+    <meta name="title" content="{{ self.title() }}">
 
     {% block head %}{% endblock head %}
 
diff --git a/templates/login_options.html b/templates/login_options.html
index c287f13f0..4825e7451 100644
--- a/templates/login_options.html
+++ b/templates/login_options.html
@@ -1,7 +1,9 @@
 {% extends 'base.html' %}
 
+{% block title %}Login to Gooey.AI{% endblock title %}
+
 {% block head %}
-    <title>Login - Gooey.AI</title>
+    <meta name="description" content="Sign in for incredible Open source, shared AI workflows."/>
     <link type="text/css" rel="stylesheet" href="https://www.gstatic.com/firebasejs/ui/6.0.2/firebase-ui-auth.css"/>
 {% endblock %}
 
diff --git a/templates/low_balance_email.html b/templates/low_balance_email.html
new file mode 100644
index 000000000..ca4a65e61
--- /dev/null
+++ b/templates/low_balance_email.html
@@ -0,0 +1,17 @@
+<p>
+    Hey {{ user.display_name }}!
+</p>
+
+<p>
+    This is a friendly reminder that your Gooey.AI balance is now just {{ user.balance }}.
+    Your account has consumed {{ total_credits_consumed }} credits in the last {{ settings.LOW_BALANCE_EMAIL_DAYS }} days.
+    <br><br>
+    To buy more credits, please visit <a href="{{ url }}">https://gooey.ai/account</a>.
+    <br><br>
+    As always, email us at sales@gooey.ai if you have any questions too. 
+    <br><br>
+    Thanks again for your business,
+    <br>
+    Sean and the Gooey.AI team
+</p>
+{{  "{{{ pm:unsubscribe }}}" }}
\ No newline at end of file
diff --git a/templates/report_email.html b/templates/report_email.html
index 098aca9bb..9e3afbf6a 100644
--- a/templates/report_email.html
+++ b/templates/report_email.html
@@ -19,6 +19,8 @@
     <br>
     Reason for Report: {{ reason_for_report }}
     <br><br>
+    In the meantime, you can go through our <a href="https://gooey.ai/docs/">docs</a> or our <a href="https://www.youtube.com/@gooeyAI/videos">video</a> tutorials. 
+    <br><br>
     {% if run_uid != user.uid %}
         Creator User ID: {{ run_uid }}
         <br>
diff --git a/tests/test_apis.py b/tests/test_apis.py
index 6412e9eda..ddd6e0e48 100644
--- a/tests/test_apis.py
+++ b/tests/test_apis.py
@@ -6,10 +6,7 @@
 from auth.auth_backend import force_authentication
 from bots.models import SavedRun, Workflow
 from daras_ai_v2.all_pages import all_test_pages
-from daras_ai_v2.base import (
-    BasePage,
-    get_example_request_body,
-)
+from daras_ai_v2.base import BasePage
 from server import app
 
 MAX_WORKERS = 20
@@ -27,7 +24,7 @@ def _test_api_sync(page_cls: typing.Type[BasePage]):
     state = page_cls.recipe_doc_sr().state
     r = client.post(
         f"/v2/{page_cls.slug_versions[0]}/",
-        json=get_example_request_body(page_cls.RequestModel, state),
+        json=page_cls.get_example_request_body(state),
         headers={"Authorization": f"Token None"},
         allow_redirects=False,
     )
@@ -45,7 +42,7 @@ def _test_api_async(page_cls: typing.Type[BasePage]):
 
     r = client.post(
         f"/v3/{page_cls.slug_versions[0]}/async/",
-        json=get_example_request_body(page_cls.RequestModel, state),
+        json=page_cls.get_example_request_body(state),
         headers={"Authorization": f"Token None"},
         allow_redirects=False,
     )
@@ -73,7 +70,7 @@ def test_apis_examples(mock_gui_runner, force_authentication, threadpool_subtest
             hidden=False,
             example_id__isnull=False,
         ):
-            threadpool_subtest(_test_apis_examples, sr)
+            threadpool_subtest(_test_apis_examples, sr, msg=sr.get_app_url())
 
 
 def _test_apis_examples(sr: SavedRun):
@@ -81,7 +78,7 @@ def _test_apis_examples(sr: SavedRun):
     page_cls = Workflow(sr.workflow).page_cls
     r = client.post(
         f"/v2/{page_cls.slug_versions[0]}/?example_id={sr.example_id}",
-        json=get_example_request_body(page_cls.RequestModel, state),
+        json=page_cls.get_example_request_body(state),
         headers={"Authorization": f"Token None"},
         allow_redirects=False,
     )
diff --git a/tests/test_low_balance_email_check.py b/tests/test_low_balance_email_check.py
new file mode 100644
index 000000000..66203a19b
--- /dev/null
+++ b/tests/test_low_balance_email_check.py
@@ -0,0 +1,127 @@
+from django.utils import timezone
+
+from app_users.models import AppUserTransaction
+from bots.models import AppUser
+from celeryapp.tasks import run_low_balance_email_check
+from daras_ai_v2 import settings
+from daras_ai_v2.send_email import pytest_outbox
+
+
+def test_dont_send_email_if_feature_is_disabled(transactional_db):
+    user = AppUser.objects.create(
+        uid="test_user", is_paying=True, balance=0, is_anonymous=False
+    )
+    settings.LOW_BALANCE_EMAIL_ENABLED = False
+    run_low_balance_email_check(user.uid)
+    assert not pytest_outbox
+
+
+def test_dont_send_email_if_user_is_not_paying(transactional_db):
+    user = AppUser.objects.create(
+        uid="test_user", is_paying=False, balance=0, is_anonymous=False
+    )
+    settings.LOW_BALANCE_EMAIL_ENABLED = True
+    run_low_balance_email_check(user.uid)
+    assert not pytest_outbox
+
+
+def test_dont_send_email_if_user_has_enough_balance(transactional_db):
+    user = AppUser.objects.create(
+        uid="test_user", is_paying=True, balance=500, is_anonymous=False
+    )
+    settings.LOW_BALANCE_EMAIL_CREDITS = 100
+    settings.LOW_BALANCE_EMAIL_ENABLED = True
+    run_low_balance_email_check(user.uid)
+    assert not pytest_outbox
+
+
+def test_dont_send_email_if_user_has_been_emailed_recently(transactional_db):
+    user = AppUser.objects.create(
+        uid="test_user",
+        is_paying=True,
+        balance=66,
+        is_anonymous=False,
+        low_balance_email_sent_at=timezone.now(),
+    )
+    settings.LOW_BALANCE_EMAIL_ENABLED = True
+    settings.LOW_BALANCE_EMAIL_DAYS = 1
+    settings.LOW_BALANCE_EMAIL_CREDITS = 100
+    run_low_balance_email_check(user.uid)
+    assert not pytest_outbox
+
+
+def test_send_email_if_user_has_been_email_recently_but_made_a_purchase(
+    transactional_db,
+):
+    user = AppUser.objects.create(
+        uid="test_user",
+        is_paying=True,
+        balance=22,
+        is_anonymous=False,
+        low_balance_email_sent_at=timezone.now(),
+    )
+    AppUserTransaction.objects.create(
+        invoice_id="test_invoice_1",
+        user=user,
+        amount=100,
+        created_at=timezone.now(),
+        end_balance=100,
+    )
+    AppUserTransaction.objects.create(
+        invoice_id="test_invoice_2",
+        user=user,
+        amount=-78,
+        created_at=timezone.now(),
+        end_balance=22,
+    )
+    settings.LOW_BALANCE_EMAIL_ENABLED = True
+    settings.LOW_BALANCE_EMAIL_DAYS = 1
+    settings.LOW_BALANCE_EMAIL_CREDITS = 100
+    run_low_balance_email_check(user.uid)
+
+    assert len(pytest_outbox) == 1
+    assert " 22" in pytest_outbox[0]["html_body"]
+    assert " 78" in pytest_outbox[0]["html_body"]
+
+    pytest_outbox.clear()
+    run_low_balance_email_check(user.uid)
+    assert not pytest_outbox
+
+
+def test_send_email(transactional_db):
+    user = AppUser.objects.create(
+        uid="test_user",
+        is_paying=True,
+        balance=66,
+        is_anonymous=False,
+    )
+    AppUserTransaction.objects.create(
+        invoice_id="test_invoice_1",
+        user=user,
+        amount=-100,
+        created_at=timezone.now() - timezone.timedelta(days=2),
+        end_balance=150 + 66,
+    )
+    AppUserTransaction.objects.create(
+        invoice_id="test_invoice_2",
+        user=user,
+        amount=-150,
+        created_at=timezone.now(),
+        end_balance=66,
+    )
+
+    settings.LOW_BALANCE_EMAIL_ENABLED = True
+    settings.LOW_BALANCE_EMAIL_DAYS = 1
+    settings.LOW_BALANCE_EMAIL_CREDITS = 100
+
+    run_low_balance_email_check(user.uid)
+    assert len(pytest_outbox) == 1
+    body = pytest_outbox[0]["html_body"]
+    assert " 66" in body
+    assert " 150" in body
+    assert " pm:unsubscribe" in body
+    assert " 100" not in body
+
+    pytest_outbox.clear()
+    run_low_balance_email_check(user.uid)
+    assert not pytest_outbox
diff --git a/tests/test_public_endpoints.py b/tests/test_public_endpoints.py
index be18647d8..31d4abea2 100644
--- a/tests/test_public_endpoints.py
+++ b/tests/test_public_endpoints.py
@@ -2,7 +2,7 @@
 from starlette.routing import Route
 from starlette.testclient import TestClient
 
-from bots.models import SavedRun
+from bots.models import PublishedRun, Workflow
 from daras_ai_v2.all_pages import all_api_pages
 from daras_ai_v2.tabs_widget import MenuTabs
 from routers import facebook_api
@@ -31,39 +31,36 @@
 
 
 @pytest.mark.django_db
-@pytest.mark.parametrize("path", route_paths)
-def test_all_get(path):
+def test_all_get(threadpool_subtest):
+    for path in route_paths:
+        threadpool_subtest(_test_get_path, path)
+
+
+def _test_get_path(path):
     r = client.get(path, allow_redirects=False)
     assert r.ok
 
 
-page_slugs = [slug for page_cls in all_api_pages for slug in page_cls.slug_versions]
-tabs = list(MenuTabs.paths.values())
+@pytest.mark.django_db
+def test_all_slugs(threadpool_subtest):
+    for page_cls in all_api_pages:
+        for slug in page_cls.slug_versions:
+            for tab in MenuTabs.paths.values():
+                url = f"/{slug}/{tab}"
+                threadpool_subtest(_test_post_path, url)
 
 
 @pytest.mark.django_db
-@pytest.mark.parametrize("slug", page_slugs)
-@pytest.mark.parametrize("tab", tabs)
-def test_page_slugs(slug, tab):
-    r = client.post(
-        f"/{slug}/{tab}",
-        json={},
-        allow_redirects=True,
-    )
-    assert r.status_code == 200
+def test_all_examples(threadpool_subtest):
+    qs = PublishedRun.objects.exclude(
+        is_approved_example=False, published_run_id=""
+    ).order_by("workflow")
+    for pr in qs:
+        slug = Workflow(pr.workflow).page_cls.slug_versions[-1]
+        url = f"/{slug}?example_id={pr.published_run_id}"
+        threadpool_subtest(_test_post_path, url)
 
 
-@pytest.mark.django_db
-def test_example_slugs(subtests):
-    for page_cls in all_api_pages:
-        for tab in tabs:
-            for example_id in SavedRun.objects.filter(
-                workflow=page_cls.workflow,
-                hidden=False,
-                example_id__isnull=False,
-            ).values_list("example_id", flat=True):
-                slug = page_cls.slug_versions[0]
-                url = f"/{slug}/{tab}?example_id={example_id}"
-                with subtests.test(msg=url):
-                    r = client.post(url, json={}, allow_redirects=True)
-                    assert r.status_code == 200
+def _test_post_path(url):
+    r = client.post(url, json={}, allow_redirects=True)
+    assert r.status_code == 200
diff --git a/tests/test_translation.py b/tests/test_translation.py
index d06b56d63..9ab1c23c0 100644
--- a/tests/test_translation.py
+++ b/tests/test_translation.py
@@ -1,3 +1,4 @@
+from conftest import flaky
 from daras_ai_v2.asr import run_google_translate
 
 
@@ -48,6 +49,7 @@ def test_run_google_translate(threadpool_subtest):
         threadpool_subtest(_test_run_google_translate_one, text, expected)
 
 
+@flaky
 def _test_run_google_translate_one(
     text: str, expected: str, glossary_url=None, target_lang="en"
 ):
diff --git a/usage_costs/__init__.py b/usage_costs/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/usage_costs/admin.py b/usage_costs/admin.py
new file mode 100644
index 000000000..fbe367243
--- /dev/null
+++ b/usage_costs/admin.py
@@ -0,0 +1,79 @@
+from django.contrib import admin
+
+from bots.admin_links import open_in_new_tab, change_obj_url
+from usage_costs import models
+
+
+class CostQtyMixin:
+    @admin.display(description="Cost / Qty", ordering="unit_cost")
+    def cost_qty(self, obj):
+        return f"${obj.unit_cost.normalize()} / {obj.unit_quantity}"
+
+
+@admin.register(models.UsageCost)
+class UsageCostAdmin(admin.ModelAdmin, CostQtyMixin):
+    list_display = [
+        "__str__",
+        "cost_qty",
+        "quantity",
+        "display_dollar_amount",
+        "view_pricing",
+        "view_saved_run",
+        "view_parent_published_run",
+        "notes",
+        "created_at",
+    ]
+    autocomplete_fields = ["saved_run", "pricing"]
+    list_filter = [
+        "saved_run__workflow",
+        "pricing__category",
+        "pricing__provider",
+        "pricing__model_name",
+        "pricing__sku",
+        "created_at",
+    ]
+    search_fields = ["saved_run", "pricing"]
+    readonly_fields = ["created_at"]
+    ordering = ["-created_at"]
+
+    @admin.display(description="Amount", ordering="dollar_amount")
+    def display_dollar_amount(self, obj):
+        return f"${obj.dollar_amount.normalize()}"
+
+    @admin.display(description="Published Run")
+    def view_parent_published_run(self, obj):
+        pr = obj.saved_run.parent_published_run()
+        return pr and change_obj_url(pr)
+
+    @admin.display(description="Saved Run", ordering="saved_run")
+    def view_saved_run(self, obj):
+        return change_obj_url(
+            obj.saved_run,
+            label=f"{obj.saved_run.get_workflow_display()} - {obj.saved_run} ({obj.saved_run.run_id})",
+        )
+
+    @admin.display(description="Pricing", ordering="pricing")
+    def view_pricing(self, obj):
+        return change_obj_url(obj.pricing)
+
+
+@admin.register(models.ModelPricing)
+class ModelPricingAdmin(admin.ModelAdmin, CostQtyMixin):
+    list_display = [
+        "__str__",
+        "cost_qty",
+        "model_id",
+        "category",
+        "provider",
+        "model_name",
+        "sku",
+        "view_pricing_url",
+        "notes",
+    ]
+    list_filter = ["category", "provider", "model_name", "sku"]
+    search_fields = ["category", "provider", "model_name", "sku", "model_id"]
+    readonly_fields = ["created_at", "updated_at"]
+
+    @admin.display(description="Pricing URL", ordering="pricing_url")
+    def view_pricing_url(self, obj):
+        return open_in_new_tab(obj.pricing_url, label=obj.pricing_url)
diff --git a/usage_costs/apps.py b/usage_costs/apps.py
new file mode 100644
index 000000000..b807e363b
--- /dev/null
+++ b/usage_costs/apps.py
@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class CostsConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "usage_costs"
+    verbose_name = "Usage Costs"
diff --git a/usage_costs/cost_utils.py b/usage_costs/cost_utils.py
new file mode 100644
index 000000000..ea622e06a
--- /dev/null
+++ b/usage_costs/cost_utils.py
@@ -0,0 +1,34 @@
+from loguru import logger
+
+from daras_ai_v2.query_params import gooey_get_query_params
+from daras_ai_v2.query_params_util import extract_query_params
+from usage_costs.models import (
+    UsageCost,
+    ModelSku,
+    ModelPricing,
+)
+
+
+def record_cost_auto(model: str, sku: ModelSku, quantity: int):
+    from bots.models import SavedRun
+
+    _, run_id, uid = extract_query_params(gooey_get_query_params())
+    if not run_id or not uid:
+        return
+
+    try:
+        pricing = ModelPricing.objects.get(model_id=model, sku=sku)
+    except ModelPricing.DoesNotExist as e:
+        logger.warning(f"Cant find pricing for {model=} {sku=}: {e=}")
+        return
+
+    saved_run = SavedRun.objects.get(run_id=run_id, uid=uid)
+
+    UsageCost.objects.create(
+        saved_run=saved_run,
+        pricing=pricing,
+        quantity=quantity,
+        unit_cost=pricing.unit_cost,
+        unit_quantity=pricing.unit_quantity,
+        dollar_amount=pricing.unit_cost * quantity / pricing.unit_quantity,
+    )
diff --git a/usage_costs/migrations/0001_initial.py b/usage_costs/migrations/0001_initial.py
new file mode 100644
index 000000000..bb02723f7
--- /dev/null
+++ b/usage_costs/migrations/0001_initial.py
@@ -0,0 +1,56 @@
+# Generated by Django 4.2.7 on 2024-02-06 18:22
+
+import bots.custom_fields
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('bots', '0057_message_response_time_and_more'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ModelPricing',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('model_id', models.TextField(help_text='The model ID. Model ID + SKU should be unique together.')),
+                ('sku', models.IntegerField(choices=[(1, 'LLM Prompt'), (2, 'LLM Completion')], help_text="The model's SKU. Model ID + SKU should be unique together.")),
+                ('unit_cost', models.DecimalField(decimal_places=10, help_text='The cost per unit.', max_digits=15)),
+                ('unit_quantity', models.PositiveIntegerField(help_text='The quantity of the unit. (e.g. 1000 tokens)')),
+                ('category', models.IntegerField(choices=[(1, 'LLM')], help_text='The category of the model. Only used for Display purposes.')),
+                ('provider', models.IntegerField(choices=[(1, 'OpenAI'), (2, 'Google'), (3, 'TogetherAI'), (4, 'Azure OpenAI')], help_text='The provider of the model. Only used for Display purposes.')),
+                ('model_name', models.CharField(choices=[('gpt_4_vision', 'GPT-4 Vision (openai)'), ('gpt_4_turbo', 'GPT-4 Turbo (openai)'), ('gpt_4', 'GPT-4 (openai)'), ('gpt_4_32k', 'GPT-4 32K (openai)'), ('gpt_3_5_turbo', 'ChatGPT (openai)'), ('gpt_3_5_turbo_16k', 'ChatGPT 16k (openai)'), ('llama2_70b_chat', 'Llama 2 (Meta AI)'), ('palm2_chat', 'PaLM 2 Chat (Google)'), ('palm2_text', 'PaLM 2 Text (Google)'), ('text_davinci_003', 'GPT-3.5 Davinci-3 (openai)'), ('text_davinci_002', 'GPT-3.5 Davinci-2 (openai)'), ('text_curie_001', 'Curie (openai)'), ('text_babbage_001', 'Babbage (openai)'), ('text_ada_001', 'Ada (openai)'), ('code_davinci_002', 'Codex [Deprecated] (openai)')], help_text='The name of the model. Only used for Display purposes.', max_length=255)),
+                ('notes', models.TextField(blank=True, default='', help_text='Any notes about the pricing. (e.g. how the pricing was calculated)')),
+                ('pricing_url', bots.custom_fields.CustomURLField(blank=True, default='', help_text='The URL of the pricing.', max_length=2048)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='UsageCost',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('quantity', models.PositiveIntegerField()),
+                ('unit_cost', models.DecimalField(decimal_places=10, help_text='The cost per unit, recorded at the time of the usage.', max_digits=15)),
+                ('unit_quantity', models.PositiveIntegerField(help_text='The quantity of the unit (e.g. 1000 tokens), recorded at the time of the usage.')),
+                ('dollar_amount', models.DecimalField(decimal_places=10, help_text='The dollar amount, calculated as unit_cost x quantity / unit_quantity.', max_digits=15)),
+                ('notes', models.TextField(blank=True, default='')),
+                ('created_at', models.DateTimeField(auto_now_add=True, db_index=True)),
+                ('pricing', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='usage_costs', to='usage_costs.modelpricing')),
+                ('saved_run', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='usage_costs', to='bots.savedrun')),
+            ],
+        ),
+        migrations.AddIndex(
+            model_name='modelpricing',
+            index=models.Index(fields=['model_id', 'sku'], name='usage_costs_model_i_d7b80a_idx'),
+        ),
+        migrations.AlterUniqueTogether(
+            name='modelpricing',
+            unique_together={('model_id', 'sku')},
+        ),
+    ]
diff --git a/usage_costs/migrations/0002_alter_modelpricing_category_and_more.py b/usage_costs/migrations/0002_alter_modelpricing_category_and_more.py
new file mode 100644
index 000000000..6097175f6
--- /dev/null
+++ b/usage_costs/migrations/0002_alter_modelpricing_category_and_more.py
@@ -0,0 +1,38 @@
+# Generated by Django 4.2.7 on 2024-02-07 15:44
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('usage_costs', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='modelpricing',
+            name='category',
+            field=models.IntegerField(choices=[(1, 'LLM'), (2, 'Self-Hosted')], help_text='The category of the model. Only used for Display purposes.'),
+        ),
+        migrations.AlterField(
+            model_name='modelpricing',
+            name='model_name',
+            field=models.CharField(choices=[('gpt_4_vision', 'GPT-4 Vision (openai)'), ('gpt_4_turbo', 'GPT-4 Turbo (openai)'), ('gpt_4', 'GPT-4 (openai)'), ('gpt_4_32k', 'GPT-4 32K (openai)'), ('gpt_3_5_turbo', 'ChatGPT (openai)'), ('gpt_3_5_turbo_16k', 'ChatGPT 16k (openai)'), ('llama2_70b_chat', 'Llama 2 (Meta AI)'), ('palm2_chat', 'PaLM 2 Chat (Google)'), ('palm2_text', 'PaLM 2 Text (Google)'), ('text_davinci_003', 'GPT-3.5 Davinci-3 (openai)'), ('text_davinci_002', 'GPT-3.5 Davinci-2 (openai)'), ('text_curie_001', 'Curie (openai)'), ('text_babbage_001', 'Babbage (openai)'), ('text_ada_001', 'Ada (openai)'), ('code_davinci_002', 'Codex [Deprecated] (openai)'), ('protogen_2_2', 'Protogen V2.2 (darkstorm2150)'), ('epicdream', 'epiCDream (epinikion)')], help_text='The name of the model. Only used for Display purposes.', max_length=255),
+        ),
+        migrations.AlterField(
+            model_name='modelpricing',
+            name='provider',
+            field=models.IntegerField(choices=[(1, 'OpenAI'), (2, 'Google'), (3, 'TogetherAI'), (4, 'Azure OpenAI'), (5, 'Azure Kubernetes Service')], help_text='The provider of the model. Only used for Display purposes.'),
+        ),
+        migrations.AlterField(
+            model_name='modelpricing',
+            name='sku',
+            field=models.IntegerField(choices=[(1, 'LLM Prompt'), (2, 'LLM Completion'), (3, 'GPU Milliseconds')], help_text="The model's SKU. Model ID + SKU should be unique together."),
+        ),
+        migrations.AlterField(
+            model_name='modelpricing',
+            name='unit_quantity',
+            field=models.PositiveIntegerField(default=1, help_text='The quantity of the unit. (e.g. 1000 tokens)'),
+        ),
+    ]
diff --git a/usage_costs/migrations/0003_alter_modelpricing_model_name.py b/usage_costs/migrations/0003_alter_modelpricing_model_name.py
new file mode 100644
index 000000000..a4cbe05fa
--- /dev/null
+++ b/usage_costs/migrations/0003_alter_modelpricing_model_name.py
@@ -0,0 +1,18 @@
+# Generated by Django 4.2.7 on 2024-02-07 16:48
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('usage_costs', '0002_alter_modelpricing_category_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='modelpricing',
+            name='model_name',
+            field=models.CharField(choices=[('gpt_4_vision', 'GPT-4 Vision (openai)'), ('gpt_4_turbo', 'GPT-4 Turbo (openai)'), ('gpt_4', 'GPT-4 (openai)'), ('gpt_4_32k', 'GPT-4 32K (openai)'), ('gpt_3_5_turbo', 'ChatGPT (openai)'), ('gpt_3_5_turbo_16k', 'ChatGPT 16k (openai)'), ('llama2_70b_chat', 'Llama 2 (Meta AI)'), ('palm2_chat', 'PaLM 2 Chat (Google)'), ('palm2_text', 'PaLM 2 Text (Google)'), ('text_davinci_003', 'GPT-3.5 Davinci-3 (openai)'), ('text_davinci_002', 'GPT-3.5 Davinci-2 (openai)'), ('text_curie_001', 'Curie (openai)'), ('text_babbage_001', 'Babbage (openai)'), ('text_ada_001', 'Ada (openai)'), ('code_davinci_002', 'Codex [Deprecated] (openai)'), ('protogen_2_2', 'Protogen V2.2 (darkstorm2150)'), ('epicdream', 'epiCDream (epinikion)'), ('dream_shaper', 'DreamShaper (Lykon)'), ('dreamlike_2', 'Dreamlike Photoreal 2.0 (dreamlike.art)'), ('sd_2', 'Stable Diffusion v2.1 (stability.ai)'), ('sd_1_5', 'Stable Diffusion v1.5 (RunwayML)'), ('dall_e', 'DALL·E 2 (OpenAI)'), ('dall_e_3', 'DALL·E 3 (OpenAI)'), ('openjourney_2', 'Open Journey v2 beta (PromptHero) 🐢'), ('openjourney', 'Open Journey (PromptHero) 🐢'), ('analog_diffusion', 'Analog Diffusion (wavymulder) 🐢'), ('protogen_5_3', 'Protogen v5.3 (darkstorm2150) 🐢'), ('jack_qiao', 'Stable Diffusion v1.4 [Deprecated] (Jack Qiao)'), ('rodent_diffusion_1_5', 'Rodent Diffusion 1.5 [Deprecated] (NerdyRodent)'), ('deepfloyd_if', 'DeepFloyd IF [Deprecated] (stability.ai)'), ('dream_shaper', 'DreamShaper (Lykon)'), ('dreamlike_2', 'Dreamlike Photoreal 2.0 (dreamlike.art)'), ('sd_2', 'Stable Diffusion v2.1 (stability.ai)'), ('sd_1_5', 'Stable Diffusion v1.5 (RunwayML)'), ('dall_e', 'Dall-E (OpenAI)'), ('instruct_pix2pix', '✨ InstructPix2Pix (Tim Brooks)'), ('openjourney_2', 'Open Journey v2 beta (PromptHero) 🐢'), ('openjourney', 'Open Journey (PromptHero) 🐢'), ('analog_diffusion', 'Analog Diffusion (wavymulder) 🐢'), ('protogen_5_3', 'Protogen v5.3 (darkstorm2150) 🐢'), ('jack_qiao', 'Stable Diffusion v1.4 [Deprecated] (Jack Qiao)'), ('rodent_diffusion_1_5', 'Rodent Diffusion 1.5 [Deprecated] (NerdyRodent)'), ('sd_2', 'Stable Diffusion v2.1 (stability.ai)'), ('runway_ml', 'Stable Diffusion v1.5 (RunwayML)'), ('dall_e', 'Dall-E (OpenAI)'), ('jack_qiao', 'Stable Diffusion v1.4 [Deprecated] (Jack Qiao)')], help_text='The name of the model. Only used for Display purposes.', max_length=255),
+        ),
+    ]
diff --git a/usage_costs/migrations/0004_alter_modelpricing_model_name.py b/usage_costs/migrations/0004_alter_modelpricing_model_name.py
new file mode 100644
index 000000000..b8130a924
--- /dev/null
+++ b/usage_costs/migrations/0004_alter_modelpricing_model_name.py
@@ -0,0 +1,18 @@
+# Generated by Django 4.2.7 on 2024-02-07 16:55
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('usage_costs', '0003_alter_modelpricing_model_name'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='modelpricing',
+            name='model_name',
+            field=models.CharField(choices=[('gpt_4_vision', 'GPT-4 Vision (openai)'), ('gpt_4_turbo', 'GPT-4 Turbo (openai)'), ('gpt_4', 'GPT-4 (openai)'), ('gpt_4_32k', 'GPT-4 32K (openai)'), ('gpt_3_5_turbo', 'ChatGPT (openai)'), ('gpt_3_5_turbo_16k', 'ChatGPT 16k (openai)'), ('llama2_70b_chat', 'Llama 2 (Meta AI)'), ('palm2_chat', 'PaLM 2 Chat (Google)'), ('palm2_text', 'PaLM 2 Text (Google)'), ('text_davinci_003', 'GPT-3.5 Davinci-3 (openai)'), ('text_davinci_002', 'GPT-3.5 Davinci-2 (openai)'), ('text_curie_001', 'Curie (openai)'), ('text_babbage_001', 'Babbage (openai)'), ('text_ada_001', 'Ada (openai)'), ('code_davinci_002', 'Codex [Deprecated] (openai)'), ('protogen_2_2', 'Protogen V2.2 (darkstorm2150)'), ('epicdream', 'epiCDream (epinikion)'), ('dream_shaper', 'DreamShaper (Lykon)'), ('dreamlike_2', 'Dreamlike Photoreal 2.0 (dreamlike.art)'), ('sd_2', 'Stable Diffusion v2.1 (stability.ai)'), ('sd_1_5', 'Stable Diffusion v1.5 (RunwayML)'), ('dall_e', 'DALL·E 2 (OpenAI)'), ('dall_e_3', 'DALL·E 3 (OpenAI)'), ('openjourney_2', 'Open Journey v2 beta (PromptHero) 🐢'), ('openjourney', 'Open Journey (PromptHero) 🐢'), ('analog_diffusion', 'Analog Diffusion (wavymulder) 🐢'), ('protogen_5_3', 'Protogen v5.3 (darkstorm2150) 🐢'), ('jack_qiao', 'Stable Diffusion v1.4 [Deprecated] (Jack Qiao)'), ('rodent_diffusion_1_5', 'Rodent Diffusion 1.5 [Deprecated] (NerdyRodent)'), ('deepfloyd_if', 'DeepFloyd IF [Deprecated] (stability.ai)'), ('dream_shaper', 'DreamShaper (Lykon)'), ('dreamlike_2', 'Dreamlike Photoreal 2.0 (dreamlike.art)'), ('sd_2', 'Stable Diffusion v2.1 (stability.ai)'), ('sd_1_5', 'Stable Diffusion v1.5 (RunwayML)'), ('dall_e', 'Dall-E (OpenAI)'), ('instruct_pix2pix', '✨ InstructPix2Pix (Tim Brooks)'), ('openjourney_2', 'Open Journey v2 beta (PromptHero) 🐢'), ('openjourney', 'Open Journey (PromptHero) 🐢'), ('analog_diffusion', 'Analog Diffusion (wavymulder) 🐢'), ('protogen_5_3', 'Protogen v5.3 (darkstorm2150) 🐢'), ('jack_qiao', 'Stable Diffusion v1.4 [Deprecated] (Jack Qiao)'), ('rodent_diffusion_1_5', 'Rodent Diffusion 1.5 [Deprecated] (NerdyRodent)'), ('sd_2', 'Stable Diffusion v2.1 (stability.ai)'), ('runway_ml', 'Stable Diffusion v1.5 (RunwayML)'), ('dall_e', 'Dall-E (OpenAI)'), ('jack_qiao', 'Stable Diffusion v1.4 [Deprecated] (Jack Qiao)'), ('wav2lip', 'LipSync (wav2lip)')], help_text='The name of the model. Only used for Display purposes.', max_length=255),
+        ),
+    ]
diff --git a/usage_costs/migrations/__init__.py b/usage_costs/migrations/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/usage_costs/models.py b/usage_costs/models.py
new file mode 100644
index 000000000..e3fce075f
--- /dev/null
+++ b/usage_costs/models.py
@@ -0,0 +1,129 @@
+from django.db import models
+
+from bots.custom_fields import CustomURLField
+from daras_ai_v2.stable_diffusion import InpaintingModels
+
+max_digits = 15
+decimal_places = 10
+
+
+class UsageCost(models.Model):
+    saved_run = models.ForeignKey(
+        "bots.SavedRun", on_delete=models.CASCADE, related_name="usage_costs"
+    )
+    pricing = models.ForeignKey(
+        "usage_costs.ModelPricing", on_delete=models.CASCADE, related_name="usage_costs"
+    )
+
+    quantity = models.PositiveIntegerField()
+    unit_cost = models.DecimalField(
+        max_digits=max_digits,
+        decimal_places=decimal_places,
+        help_text="The cost per unit, recorded at the time of the usage.",
+    )
+    unit_quantity = models.PositiveIntegerField(
+        help_text="The quantity of the unit (e.g. 1000 tokens), recorded at the time of the usage."
+    )
+
+    dollar_amount = models.DecimalField(
+        max_digits=max_digits,
+        decimal_places=decimal_places,
+        help_text="The dollar amount, calculated as unit_cost x quantity / unit_quantity.",
+    )
+
+    notes = models.TextField(default="", blank=True)
+
+    created_at = models.DateTimeField(auto_now_add=True, db_index=True)
+
+    def __str__(self):
+        return f"{self.saved_run} - {self.pricing} - {self.quantity}"
+
+
+class ModelCategory(models.IntegerChoices):
+    LLM = 1, "LLM"
+    SELF_HOSTED = 2, "Self-Hosted"
+
+
+class ModelProvider(models.IntegerChoices):
+    openai = 1, "OpenAI"
+    google = 2, "Google"
+    together_ai = 3, "TogetherAI"
+    azure_openai = 4, "Azure OpenAI"
+
+    aks = 5, "Azure Kubernetes Service"
+
+
+def get_model_choices():
+    from daras_ai_v2.language_model import LargeLanguageModels
+    from recipes.DeforumSD import AnimationModels
+    from daras_ai_v2.stable_diffusion import Text2ImgModels, Img2ImgModels
+
+    return (
+        [(api.name, api.value) for api in LargeLanguageModels]
+        + [(model.name, model.label) for model in AnimationModels]
+        + [(model.name, model.value) for model in Text2ImgModels]
+        + [(model.name, model.value) for model in Img2ImgModels]
+        + [(model.name, model.value) for model in InpaintingModels]
+        + [("wav2lip", "LipSync (wav2lip)")]
+    )
+
+
+class ModelSku(models.IntegerChoices):
+    llm_prompt = 1, "LLM Prompt"
+    llm_completion = 2, "LLM Completion"
+
+    gpu_ms = 3, "GPU Milliseconds"
+
+
+class ModelPricing(models.Model):
+    model_id = models.TextField(
+        help_text="The model ID. Model ID + SKU should be unique together."
+    )
+    sku = models.IntegerField(
+        choices=ModelSku.choices,
+        help_text="The model's SKU. Model ID + SKU should be unique together.",
+    )
+
+    unit_cost = models.DecimalField(
+        max_digits=max_digits,
+        decimal_places=decimal_places,
+        help_text="The cost per unit.",
+    )
+    unit_quantity = models.PositiveIntegerField(
+        help_text="The quantity of the unit. (e.g. 1000 tokens)", default=1
+    )
+
+    category = models.IntegerField(
+        choices=ModelCategory.choices,
+        help_text="The category of the model. Only used for Display purposes.",
+    )
+    provider = models.IntegerField(
+        choices=ModelProvider.choices,
+        help_text="The provider of the model. Only used for Display purposes.",
+    )
+    model_name = models.CharField(
+        max_length=255,
+        choices=get_model_choices(),
+        help_text="The name of the model. Only used for Display purposes.",
+    )
+
+    notes = models.TextField(
+        default="",
+        blank=True,
+        help_text="Any notes about the pricing. (e.g. how the pricing was calculated)",
+    )
+    pricing_url = CustomURLField(
+        default="", blank=True, help_text="The URL of the pricing."
+    )
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        unique_together = ["model_id", "sku"]
+        indexes = [
+            models.Index(fields=["model_id", "sku"]),
+        ]
+
+    def __str__(self):
+        return f"{self.get_provider_display()} / {self.get_model_name_display()} / {self.get_sku_display()}"
diff --git a/usage_costs/tests.py b/usage_costs/tests.py
new file mode 100644
index 000000000..7ce503c2d
--- /dev/null
+++ b/usage_costs/tests.py
@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.
diff --git a/usage_costs/views.py b/usage_costs/views.py
new file mode 100644
index 000000000..91ea44a21
--- /dev/null
+++ b/usage_costs/views.py
@@ -0,0 +1,3 @@
+from django.shortcuts import render
+
+# Create your views here.