Quickstart
PromptForm is a no-code / low-code platform that allows users to build and use Apps (Agents) that complete tasks across all functions of a Marketing Agency.
Example App: Blog Writer
Example App: Client Report
Example App: Competitor Research
PromptForm Apps consist of Input Fields, Models, Utilities, Integrations, Prompts, Logic, and Outputs.
Input Fields
Users give instructions and provide input to Apps through Input Fields. Each input field can be customized to include the following attributes:
Attributes
Name: A unique identifier for the input field.
Title: A label that describes the purpose of the input field.
Placeholder Text: A short hint or example displayed in the field until the user provides input.
Tooltip: A small pop-up description providing additional information about the input field.
Conditional Logic: Rules that determine when and how the input field appears or behaves.
Input Field Types
Text - A single-line input field for short text entries.
e.g.- Product Name: Morino Wool Socks
Textarea - A multi-line input field for longer text entries.
e.g.- Customer Description: Males, ages 20 - 35 who are software engineers living in major cities. Work for large companies, making over $200K USD a year. They live in Condo’s and drive a luxury vehicle.
Number - A numeric input field.
e.g.- Number of words: 2000
Range - A slider input to select a value within a defined range.
e.g. - # of Variations: 0 - 100
Options - A dropdown, checkbox, or radio button input for selecting one option from a list.
e.g. - Select Writing Style: Funny, Serious, Playful, Professional, Curious
Audio - An input field to upload or record audio files.
e.g. - Story: Record or Upload a Recording
Read Only - An editable input field to display static information or pre-filled values.
e.g. - Example:
Models
PromptForm can route prompts to various Text, Image, Audio, and Video generation AI Models. Models should be selected based on modality, task type, and performance. New Models are always being released.
Modalities: Text, Image, Audio, and Video
Common Task Types that Models are used for:
Plan
Reason
Summarize
Extract
Reflect
Format
Review
Edit
Tools
Model performance is correlated to the task type. You want to use a larger model e.g. GPT-o1, to do good planning. To do summarization, you want to use a smaller model, e.g. OpenAI - GPT-o1 Mini.
The cost variation between models is negligible and has no impact on the App’s usefulness. Do not optimize for cost unless your App is at scale = 1000 runs per day.
Text Generation
Apps can use any of the available text generation models. Models are constantly being updated. New Models are released consistently.
Choosing the Right Text Model:
When building your app, consider the following when selecting a text generation model:
Task Complexity: For complex tasks like detailed planning, in-depth reasoning, or creative writing, larger models like GPT-4o generally perform better. For simpler tasks like summarization or basic text generation, smaller models can be more efficient and cost-effective.
Output Quality: Larger models tend to produce higher quality, more coherent, and contextually relevant output. However, smaller models may suffice if the task doesn't require high levels of nuance.
Speed: Smaller models typically process prompts and generate output faster than larger models. If your app requires real-time or near real-time responses, consider using a smaller, faster model.
Cost: In general, larger models are more expensive to use than smaller models.
Testing and Iteration:
It's crucial to test your app with different models and prompts to find the optimal combination for your specific use case. PromptForm allows you to easily experiment with various models, so take advantage of this feature to fine-tune your app's performance.
Open AI
gpt 4o (omni)
gpt o1 (reasoning)
gpt o1 mini
Anthropic
Claude 3.5 Sonnet
Claude 3.7 Sonnet
Perplexity
Llama 3.1 Sonar Small Online
Llama 3.1 Sonar Large Online
Gemini
Gemini Pro 1.5
Image Generation
Choosing the Right Image Model:
Style and Realism: Different image models excel at different artistic styles (e.g., photorealistic, painterly, abstract). Choose a model that aligns with the desired aesthetic of your app.
Resolution and Detail: Some models generate higher-resolution images with more intricate details than others. Consider the level of detail required for your app's use case.
Speed: Image generation speed can vary between models. If your app needs to generate images quickly, prioritize a faster model.
PromptForm API integrations for Image Generation:
Stable Diffusion
Strengths:
High-Quality and Detailed Images: Stable Diffusion is known for generating high-resolution images with a good level of detail.
Versatile Styles: It can produce a wide range of artistic styles, from photorealistic to painterly, abstract, and more.
Large Community and Resources: Being one of the most popular models, it benefits from a large community, which means more resources, tutorials, and fine-tuned models are available.
Customization: Stable Diffusion offers a high degree of customization through various parameters and extensions. It's excellent for users who want more control over the image generation process.
Open Source: Its open-source nature allows for extensive community development, custom models, and unique applications.
Typical Use Cases:
Generating realistic images: Creating lifelike images of people, objects, and scenes.
Artistic image creation: Producing digital art in various styles, such as oil painting, watercolor, or anime.
Concept art: Visualizing ideas for games, movies, or other creative projects.
Image-to-image transformations: Modifying existing images based on text prompts (e.g., changing the style of a photo).
Custom model training: Fine-tuning the model on specific datasets to generate images in a particular style or of specific subjects.
Ideogram
Strengths:
Text-to-Image Specialization: Ideogram excels at generating images that accurately incorporate text within the image itself, making it ideal for creating designs with text elements.
Creative Layouts: It's adept at producing visually appealing and creative layouts, making it suitable for marketing materials, social media posts, and more.
User-Friendly: Ideogram is designed to be easy to use, even for those without extensive experience in AI image generation.
High Accuracy: It often produces images that closely match the user's prompt, especially when it comes to incorporating specific details.
Typical Use Cases:
Logo design: Creating logos that incorporate text in a visually appealing way.
Social media graphics: Generating eye-catching graphics with text overlays for social media posts.
Marketing materials: Designing posters, flyers, and other marketing materials that combine text and images.
Personalized products: Creating custom designs for t-shirts, mugs, and other personalized products.
Meme Generation: Quickly creating humorous or engaging memes.
Flux
Strengths:
Speed and Efficiency: Flux is optimized for fast image generation, making it suitable for applications that require quick results.
User-Friendly Interface: It's designed to be accessible and easy to use, making it a good choice for beginners.
Specific Style Focus: Flux might be trained or fine-tuned to excel in specific artistic styles or image types.
Typical Use Cases:
Rapid prototyping: Quickly generating images to test different ideas or concepts.
Real-time applications: Integrating image generation into interactive applications where speed is crucial.
Generating variations: Quickly creating multiple variations of an image based on a single prompt.
Simple image creation: Producing images for social media, blog posts, or other content where high levels of detail are not required.
Audio & Video Generation
PromptForm API integrations for Audio Generation:
Okay, here's an overview of the audio and video generation models, including ElevenLabs, RunwayML, D-ID, and Kling, along with their strengths and typical use cases:
Audio & Video Generation Models: Strengths and Use Cases
PromptForm offers integration with various cutting-edge AI models for audio and video generation. Choosing the right model depends on your specific needs regarding voice, style, customization, and the type of content you want to create.
ElevenLabs
Strengths:
Realistic Text-to-Speech: ElevenLabs is renowned for its highly realistic and natural-sounding text-to-speech (TTS) technology. It can generate speech that is often indistinguishable from a human voice.
Multilingual Support: ElevenLabs supports a wide range of languages and accents, making it suitable for creating content for global audiences.
Emotional Range: It can generate speech with different emotions and tones, allowing you to create more engaging and dynamic audio content.
Typical Use Cases:
Audiobook Narration: Creating high-quality audiobooks with natural-sounding voices.
Voiceovers: Generating voiceovers for videos, podcasts, and other multimedia content.
Character Voices: Bringing digital characters to life with unique and expressive voices.
Accessibility: Converting written text into speech for visually impaired users.
Language Learning: Creating audio content for language learning materials.
RunwayML
Strengths:
Versatile Video Editing and Generation: RunwayML is a comprehensive platform for both video editing and AI-powered video generation. It offers a wide array of tools and models.
Typical Use Cases:
Creating Short Videos: Generating short video clips for social media, marketing, or other purposes.
Prototyping and Experimentation: Quickly testing out different video ideas and concepts.
D-ID
Strengths:
Talking Head Videos from Still Images: D-ID specializes in creating realistic "talking head" videos from a single photograph. It animates the facial features of a still image to make it appear as if the person is speaking.
Text-to-Video: You can generate videos by providing text that the avatar will speak.
Preset Avatars: D-ID allows you to choose the appearance and voice of your avatars.
Typical Use Cases:
Virtual Presenters: Creating virtual presenters for training videos, webinars, or online courses.
Personalized Videos: Generating personalized video messages for marketing or customer service.
Accessibility: Providing a visual representation of text for users who may have difficulty reading.
Kling
Strengths:
High-Quality Video Generation: Kling, developed by Kuaishou, is a newer text-to-video model that has gained attention for its ability to generate high-quality, realistic videos.
Longer Video Length: Reportedly capable of generating longer videos (up to 2 minutes) compared to some other models.
High Resolution: Supports generating videos in 1080p resolution.
Realistic Motion and Physics: Kling is trained to simulate real-world physics and motion, which can result in more realistic movements within the generated videos.
Typical Use Cases: (Similar to other text-to-video models, but with potentially higher quality and longer durations)
Short Film Creation: Generating short films or scenes from text descriptions.
Marketing and Advertising: Creating engaging video content for promotional purposes.
Social Media Content: Producing short, eye-catching videos for social media platforms.
Storyboarding and Visualization: Helping to visualize scripts or storyboards.
Choosing the Right Model:
For realistic text-to-speech and voice cloning, ElevenLabs is the clear leader.
For versatile video editing and AI-powered video generation with a user-friendly interface, RunwayML is a strong choice.
For creating talking head videos from still images, D-ID is the go-to solution.
For generating high-quality, potentially longer videos from text prompts, Kling is a promising new option.
Utilities
Apps can have Utilities that provide common functionality to enhance the users experience and usefulness of the app.
Display
Purpose: The Display utility is used to show text or information within the app. As the name suggests, it simply displays whatever is in the field.
Functionality:
Displays plain text, HTML, or rich text.
Can be used to store information for use in prompts. This allows you to set up instructions, guides, or specific prompts that you reuse throughout your app.
You can hide the display from showing while still referencing and using its content in other prompts. This is similar to using a variable in programming.
Example: You could store a set of instructions for generating a specific type of output in a hidden Display utility and then reference that utility in multiple prompts, ensuring consistency across your app.
Interactive
Purpose: The Interactive utility pauses the workflow and requires the user to interact by providing input or selecting an option before the workflow can continue.
Functionality:
Pauses the prompt output.
Prompts the user to either select an option or fill in information.
The workflow resumes only after the user has interacted.
Example: You could use the Interactive utility to ask the user to choose between different writing styles (e.g., formal, informal, humorous) before generating a text output.
Code
Purpose: The Code utility allows you to execute JavaScript or Python code within your app.
Functionality:
Executes JavaScript or Python code.
Useful for overcoming limitations in the platform by writing custom code.
Example: If you encounter a specific functionality that is not directly supported by PromptForm's built-in features, you can often implement it using the Code utility.
URL Scraper
Purpose: The URL Scraper utility can be used to extract data from web pages or to connect to APIs.
Functionality:
Web Scraping: Enter a URL, and it will scrape the text or HTML content of that web page.
API Connector: Acts as an API connector, allowing you to connect to most APIs that use GET, POST, or PUT requests.
Advanced Options: Offers advanced options like different request formats.
Example:
Web Scraping: You could use the URL Scraper to extract product descriptions from an e-commerce website.
API Connection: You could connect to a weather API to retrieve weather data for a specific location.
YouTube Transcript
Purpose: The YouTube Transcript utility extracts the transcript from a YouTube video.
Functionality:
Retrieves the transcript of a YouTube video if one is available.
Requires the YouTube video URL as input.
Example: You could use the YouTube Transcript utility to extract the transcript of a tutorial video and then use that text as input for other prompts in your app.
WebSearch EXA
Purpose: The WebSearch EXA utility allows you to perform web searches using the Exa platform.
Functionality:
Uses the Exa platform (formerly known as Metaphor) for web searches.
Exa has indexed the web and uses a vector-style database and retrieval system.
Provides a powerful web search functionality within your app.
Example: You could use the WebSearch EXA utility to search for the latest news on a particular topic or to gather information from websites relevant to your app's purpose.
Image Utility
Purpose: The Image Utility allows for conversion between image formats.
Functionality:
Converts between various image formats.
Example: If an uploaded image is a PNG file but the app requires a JPEG file, the Image Utility can be used to automatically make this conversion.
Integrations
Apps can connect to any API service using GET or POST. Integrations allow App’s to access third-party data sources that Models cannot. PromptForm comes with standard integrations, and the ability to customize Integrations.
Benefits of Using Integrations:
Access External Data: Connect your PromptForm apps to a vast range of data sources and services not directly accessible to the AI models.
Enhance App Functionality: Create more dynamic and interactive apps that can retrieve and manipulate real-time data.
Automate Workflows: Combine API integrations with other PromptForm features to automate complex workflows.
How Integrations Work in PromptForm
Integrations in PromptForm work in two ways:
Connect to various APIs using the URL Scraper utility.
Connect to hundreds of other services using sites like Zapier.com
The URL Scraper
Pulling data from another API for use in an app can be configured through the URL Scraper utility. While it's named "URL Scraper," it's a versatile tool that can act as a powerful API connector.
Key Features of the URL Scraper for API Integration:
- URL:
- This is where you enter the API endpoint you want to connect to.
You can make this dynamic by adding variables from the Inputs or from other Prompts. This is done by writing the name of the variable or Prompt and selecting from the dropdown.
URL Paths:
This section is used for creating dynamic URLs. Each path that is added will be appended to the base URL.
To make this dynamic, select a value from the dropdown.
URL Parameters:
Parameters can be added to pass information to the API endpoint. You can add parameters by clicking Add Parameter. Each parameter consists of a Name and a Value.
The Name will often be static, while the Value can be made dynamic by selecting from the dropdown.
Headers:
Some API's require headers. You can add headers by clicking Add Header. Each header consists of a Name and a Value.
The Name will often be static, while the Value can be made dynamic by selecting from the dropdown.
Request Data:
Some API's require data to be sent along with the request. You can add request data by clicking Add Request Data. Each request data consists of a Name and a Value.
The Name will often be static, while the Value can be made dynamic by selecting from the dropdown.
Request Method:
Choose the HTTP method for your API request:
GET: Retrieve data from the API.
POST: Send data to the API (often used to create or update resources).
POST - JSON: Sends data in JSON format.
POST - Form: Sends data in form-encoded format.
POST - Raw: Sends data as-is. This can be useful for sending data in XML format, for example.
PUT: Update an existing resource.
Scrape Mode:
Text only: Scrapes all the text from the API response.
Full content: Scrapes all the HTML content from the API response.
CSS Selector:
This is used for web scraping. If you need to extract specific elements from an HTML page, you can use CSS selectors to target those elements. If this is left empty, the entire page will be scraped.
Result Format:
Choose the format you want the results to be returned in (Markdown, HTML, Code, etc.). This is useful for controlling how the API response is presented within your app.
Example: Using the URL Scraper to Connect to an API
Let's say you want to integrate with a hypothetical weather API that provides weather information based on a zip code. The API endpoint is:
https://weatherapi.example.com/current?zip={zipcode}
Here's how you would configure the URL Scraper:
URL: https://weatherapi.example.com/current
URL Paths:
You could make this dynamic by selecting a Query from the Inputs dropdown.
URL Parameters:
Name: zip
Value: 90210 (or dynamically select a zip code Input field)
Headers:
Name: Authorization
Value: Bearer your_api_token
Request Data: (Not required for this example)
Request Method: GET
Scrape Mode: Text only (since we expect a text-based JSON response)
CSS Selector: (Leave empty as this is an API and not web scraping)
Result Format: Code (to neatly display the JSON response)
Custom Integrations:
The ability to connect to virtually any API using GET or POST requests makes PromptForm's integration capabilities extremely flexible. You can build custom integrations to connect to:
Internal APIs: Access data and services within your own organization.
Specialized APIs: Integrate with niche APIs for specific industries or tasks.
Any Web Service: Connect to any web service that exposes an API.
Zapier
This guide explains how to use Zapier to run your PromptForm app and how to retrieve results using either Webhooks or directly via Zapier.
Running a PromptForm App from Zapier
Prerequisites
A PromptForm account with an app created.
A Zapier account.
A Google account (for using Google Forms and Sheets).
Steps
Trigger the Zap with Google Forms:
Create a Google Form to collect the necessary input for your PromptForm app (e.g., company name).
In Zapier, create a new Zap.
Choose "Google Forms" as the trigger app.
Select "New Form Response" as the trigger event.
Connect your Google account and select the form you created.
Set up a Custom Request in Webhooks by Zapier:
Add a new action step in Zapier.
Choose "Webhooks by Zapier" as the action app.
Select "Custom Request" as the action event.
Configure the custom request as follows:
Method: POST
URL: https://app.promptform.ai/api/run/YOUR_APP_ID (replace YOUR_APP_ID with your app's ID).
Data Pass Through?: false
Data:
{
"input#1": "Company Name from Google Forms"
}
content_copy
download
Use code with caution.
Unflatten: yes
Basic Auth: Leave empty.
Headers:
Content-Type: application/json
Authorization: Bearer YOUR_API_KEY (replace YOUR_API_KEY with your API key from PromptForm).
Enable API Access and Get API Key in PromptForm:
Go to your PromptForm app and click "Edit".
Scroll down and enable "Enable API Access".
Click the "API" button.
To create an API key, click "Select API Key" in the top right, then "Add API Key." Name it (e.g., "Zapier") and click "Add Key."
Select your newly created API key from the dropdown.
Copy the Bearer token (including the word "Bearer") from the provided code example.
Test the Zap:
Click "Continue" in Zapier and test the action.
You should see a result and success: true in the output.
Retrieving Results
Method 1: Using Webhooks (Recommended)
Steps
Create a Webhook Trigger in a New Zap:
Create a new Zap in Zapier.
Choose "Webhooks by Zapier" as the trigger app.
Select "Catch Hook" as the trigger event.
Copy the webhook URL provided by Zapier.
Add Webhook to PromptForm App:
Go to your PromptForm app and click "Edit."
Scroll down to the "Call Zap" section.
Paste the webhook URL into the "URL" field.
Add a "Request Data" parameter with the key Result and select the output you want to send to Zapier (e.g., "Company Explanation").
Click "Save."
Process Results in Zapier:
Add an action step in Zapier to process the data received from the webhook (e.g., "Create Spreadsheet Row in Google Sheets").
Map the fields from the webhook output to the corresponding columns in your Google Sheet.
Test the Zap:
Submit a new response to your Google Form.
The Zap should run, and the results from your PromptForm app should be added to your Google Sheet.
Method 2: Direct Retrieval via Zapier (More Complex)
Steps
Add a Delay Step:
After the "Custom Request" action, add a "Delay by Zapier" action.
Set the delay to at least 1 minute to allow PromptForm to process the request.
Add Another Custom Request to Get Results:
Add another "Webhooks by Zapier" action with "Custom Request."
Configure the custom request as follows:
Method: GET
URL: https://app.promptform.ai/api/result/RESULT_ID (replace RESULT_ID with the result ID from the first "Custom Request" action).
Data Pass Through?: false
Headers:
Authorization: Bearer YOUR_API_KEY
Add a Filter (Optional):
Add a "Filter by Zapier" action to ensure the Zap only continues if the PromptForm app has finished processing.
Set the filter condition to Status exactly matches completed.
Process Results:
Add an action step to process the results (e.g., "Create Spreadsheet Row in Google Sheets").
Map the fields from the second "Custom Request" output to your Google Sheet.
Test the Zap:
Submit a new response to your Google Form.
The Zap should run, wait for the specified delay, retrieve the results, and add them to your Google Sheet.
Notes:
The direct retrieval method has limitations due to potential delays in PromptForm's processing. The webhook method is generally more reliable.
You can disable steps in your Zap by clicking the three dots next to the step number and then choosing “Delete”. This will delete the step, and the remaining steps will be renumbered. You can then add the new step back in, but the step numbering of the subsequent steps will have changed, so be sure to update any references to these steps.
Prompts
Prompts are the building blocks of Apps. Prompts consist of Models, Attributes, and Output Format
Logic / Flows
Customize your app’s path based on user choices, using a flow editor.
See a video here
Step 1: Access the Flow Editor
Scroll to the bottom of your app’s main screen.
Locate the “Flow Editor” button next to “Duplicate”. Click on it to open a new page titled “Flow Editor”.
Step 2: Understanding the Flow Editor Layout
You’ll see a list of nodes, starting with the “Start Node” at the top.
The sequence flows downward from the “Start Node”.
Step 3: Implementing Conditional Logic
Add an If Condition:
On the right-hand side, find the option to drag an “If Condition” into your sequence.
Use this to create branching paths based on user input.
Configure the If Condition:
Define the condition, e.g., check if the input contains the word “customize”.
Decide the path for “Yes” (true) and “No” (false) based on the condition.
Step 4: Creating Branches
Connect nodes to form paths:
Drag and drop nodes to link the “Yes” path or the “No” path to the subsequent actions or prompts.
Step 5: Saving and Modifying Flows
Save the Flow:
Once you’re satisfied with the setup, save your flow to lock it in place.
Editing Existing Flows:
New prompts will appear with a white background; drag them into the desired position.
Save the flow after making changes to ensure updates are applied.
Step 6: Testing the App Flow
Run Flow:
Use the “Run Flow” option to preview the app’s behavior.
Enter input data and choose paths to observe the flow in action.
Verify Path Execution:
Check if the app follows the correct paths based on the input.
Confirm that the actions (e.g., summarizing) are executed as expected.
Step 7: Finalizing and Editing
To return to editing the app, click the “Edit App” button.
If no changes are needed, exit the flow editor.
Outputs
Both Prompts and Apps can have any number or type of Output. Outputs should be selected based on the Task Type.
Outputs can be structured and non-structured.
Types:
Markdown
Functionality: Handles both Markdown and HTML. This is because sometimes a language model might return HTML even when Markdown is requested.
Use Case: Ideal when you need an output format that supports basic text formatting, lists, headings, links, and images, and can also render HTML in cases where the model provides it.
HTML
Functionality: Specifically looks for and renders HTML.
Use Case: Use this when you expect the output to be in HTML format and you want it to be rendered as a webpage would display it. Useful for creating web content directly from the app.
Code
Functionality: Formats the output as code, making it appear as it would in a code editor. Supports syntax highlighting for various programming languages, such as Python, XML, JSON and many others.
Use Case: Select this when the output is a code snippet (e.g., Python, XML, JSON) and you want it to be displayed with proper code formatting and syntax highlighting, making it easier to read and copy.
JSON
Functionality: Formats the output as JSON. When you choose JSON, a new button appears beside it, allowing you to configure your structured output. This button only appears when JSON is selected.
Use Case: Ideal for generating structured data that can be easily used by other applications or systems.
Availability of the JSON Option: The JSON structured output option is not available for all LLMs. Currently, as of this writing, it shows up under the OpenAI models, specifically the 4o model.
Choosing the Right Output Type:
The choice of output type depends on the nature of the task and how you intend to use the generated output. Consider whether you need a human-readable format like Markdown, a web-ready format like HTML, a code-specific format like Code, or a machine-readable structured format like JSON.
Actions
Users take the Outputs of Apps and perform a variety of Actions. The App builder configures Actions.
Types:
Decision
Edit
Copy and Paste
Send to another App
Download
Share
Save
Automate