Skip to main content

Item Submission Criteria

Item Submission Standards​

Below, you'll find the criteria our Submission Review Team uses to review items submitted to FlutterFlow Marketplace.

1. Originality and Ownership​

1.1 Project Ownership​

  • Criteria: You must own the rights to the project you submit.
  • Why it Matters: Only the original creator has the right to share and potentially sell their work. This ensures fairness, prevents unauthorized distribution, and protects intellectual property.
  • What To Do:
    • If you're the sole creator: Great! Make sure you're submitting the project from your own FlutterFlow account.
    • If you're collaborating: The project owner should be the one to submit it to Marketplace. Discuss this with your collaborators beforehand.
    • If you've acquired a project: Ensure the original creator has officially transferred ownership rights to you. This may involve legal documentation, so it's important to handle it properly.

1.2 Significant Edits Made​

  • Criteria: Projects must demonstrate a substantial amount of original work and editing.
  • Why It Matters: The Marketplace thrives on innovation and creativity. Minor cosmetic tweaks to existing projects don't offer the same value as fundamentally unique creations or heavily modified versions showcasing your distinct design and development skills.
  • What To Do:
    • Highlight your modifications: Clearly demonstrate the unique components, functionalities, or design choices you've implemented.
    • Go beyond superficial changes: If your modifications are primarily visual (e.g., color swaps, logo replacements), consider adding more substantive improvements.

1.3 Not Based on an Existing Marketplace Item​

  • Criteria: Projects must not be direct derivatives of existing Marketplace items.
  • Why It Matters: Originality is key! Duplicating existing offerings diminishes the diversity and value of Marketplace. We want to empower users with a wide range of unique choices.
  • What To Do:
    • Draw inspiration, don't duplicate: While you can certainly learn from existing projects, aim to differentiate yours significantly.
    • Add your own flavor: Infuse your unique style, features, or functionalities to make the project distinctively yours.

1.4 Not Based on a Sample App​

  • Criteria: Submissions should not be minimally modified versions of FlutterFlow's provided sample apps.
  • Why It Matters: Sample apps are fantastic learning tools, but Marketplace items should showcase a higher level of complexity and original thought.
  • What To Do:
    • Use sample apps as a foundation: Treat them as a starting point. Experiment, expand, and transform them into something new.
    • Demonstrate advanced skills: Go beyond basic layouts and features; integrate custom code, complex animations, or add helpful API calls.

1.5 Original Project Content​

  • Criteria: All project content—text, images, designs—must be original or appropriately licensed for commercial use. Please see Legal Guidelines for Creators and Navigating External Licenses for more info.
  • Why It Matters: Using copyrighted material without permission can lead to legal issues and undermines the professional nature of Marketplace.
  • What To Do:
    • Create your own assets: This is the best way to ensure originality.
    • Use royalty-free resources and properly licensed code: Several websites offer high-quality, free-to-use assets. See also our guidance on Open Source Licenses.
    • Purchase commercial licenses: If you choose to use paid assets, secure the appropriate license for commercial distribution. This can be really tricky, so please review Licenses from Other Marketplaces and Navigating External Licenses.

1.6 No Library Dependencies (Libraries Only)​

  • Criteria: Libraries cannot depend on other libraries.
  • Why It Matters: Dependencies between libraries create complexity in permissions management and version control, potentially leading to compatibility issues or broken functionality.
  • What To Do:
    • Build Self-Contained: Ensure your library contains all necessary functionality without requiring other libraries (from Marketplace or personal libraries).
info

When you publish a free item to Marketplace, you agree to license it under the MIT License, which grants users perpetual rights to use, modify, and distribute the project. Paid items are subject to the license terms specified in our Marketplace Terms of Service.

While creators may remove their items from Marketplace at any time, this does not affect the rights of users who obtained the item while it was published - they retain their license rights according to the terms that were in effect when they acquired the item.

Please review our Legal Guidelines for Creators for more details about licensing and intellectual property rights.

2. Metadata​

Clear, engaging, and accurate metadata helps users discover and understand the value of your project.

2.1 Submission in English​

  • Criteria: All item metadata (title, description, tags, etc.) must be in English.
  • Why it Matters: To ensure a broad understanding among our global community, all Marketplace items must be in English.
  • What To Do: Use clear, concise English throughout your submission. If English isn't your first language, consider using FlutterFlow's automatic translation feature.

2.2 Professional Title​

  • Criteria: Your project title should be clear, concise, and free of grammatical errors.
  • Why it Matters: A strong title grabs attention and communicates the essence of your project at a glance.
  • What To Do:
    • Keep it brief and impactful: Aim for a title that's easy to remember and accurately reflects the core purpose of your project.
    • Use relevant keywords: This helps users find your project when searching on Marketplace.
    • Proofread carefully: Typos and grammatical errors create a negative first impression.

2.3 Unique Title​

  • Criteria: Your title should be distinct from other items in Marketplace.
  • Why it Matters: A unique title helps your project stand out and prevents confusion among users.
  • What To Do:
    • Research existing titles: Before settling on a title, do a quick search to make sure it isn't already in use.
    • Get creative with wording: If you find similar titles, brainstorm alternative phrases or keywords that accurately describe your project's unique selling points.

2.4 Professional Description​

  • Criteria: Your project description should be well-written, engaging, and free of grammatical errors.
  • Why it Matters: The description provides users with a deeper understanding of your project's features, benefits, and intended use cases.
  • What To Do:
    • Start with a strong opening: Capture attention from the start and clearly state what your project does.
    • Highlight key features: Use bullet points or formatting to make it easy to scan for important information.
    • Focus on benefits: Explain why someone would want to use your item – what problems does it solve or what opportunities does it unlock?
    • Proofread meticulously: Errors in grammar and spelling can make your project seem unprofessional.
warning

While tools like ChatGPT can assist in drafting content, they often generate generic text that might not fully capture the unique aspects of your project or could sound overly promotional and insincere. Always personalize and proofread AI-generated content to ensure it aligns with your item's features and capabilities.

2.5 Accurate Description​

  • Criteria: The description should accurately reflect the project's functionality and avoid exaggerating its capabilities.
  • Why it Matters: Misleading descriptions lead to negative user experiences. Transparency builds trust within Marketplace.
  • What To Do:
    • Be truthful and transparent: Clearly state what your project can and cannot do.
    • Avoid hype and jargon: Focus on clear, concise language that everyone can understand. Do not overpromise.

2.6 Third-Party Service Information​

  • Criteria: If your project relies on any external services or APIs, you must disclose this information in the description.
  • Why it Matters: Transparency about potential additional costs or dependencies ensures users have all the information needed to make an informed decision before purchasing or cloning an item.
  • What To Do:
    • List all external services: Include the name of the service, its purpose within your project, and whether it requires a paid subscription or API key.
    • Provide links (if applicable): Direct users to relevant documentation or pricing pages for the third-party service.

2.7 Professional Instructions​

  • Criteria: Instructions and documentation should be clear, easy to follow, and written in a professional tone.
  • Why it Matters: Well-written instructions ensure a smooth setup and implementation experience for users, increasing customer satisfaction.
  • What To Do:
    • Assume no prior knowledge: Write for someone who's completely new to your project and FlutterFlow.
    • Use numbered steps: Break down complex processes into manageable, actionable steps.
    • Include video links: Use the documentation URL to point users to a visual video walkthrough. Alternatively, point users to a Google Doc or similar written documentation for your item.
    • Test your instructions: Have someone else follow your instructions to identify any points of confusion.

2.8 Accurate Tags​

  • Criteria: Use relevant tags that accurately describe your project's category, features, and functionality.
  • Why it Matters: Tags play a crucial role in helping users discover your project through Marketplace search.
  • What To Do:
    • Think like a user: What keywords would someone use to search for a project like yours?
    • Use a mix of broad and specific tags: For example, use general tags like "e-commerce" or "social media" along with more specific ones like "shopping cart" or "user authentication".
    • Don't use irrelevant tags: This only makes it harder for users to find what they're looking for.

2.9 High-Quality Images​

  • Criteria: Images should be visually appealing, high-resolution, and representative of the project's design and functionality. Cover images should be at least 1200 x 800 pixels and in 1.5 aspect ratio.
  • Why it Matters: Images are the first thing users see – make a great visual impression!
  • What To Do:
    • Showcase key screens and features: Select images that highlight the most visually impressive and important aspects of your project.
    • Use high-resolution images: Avoid blurry or pixelated images.
    • Maintain a consistent style: Use similar image dimensions and visual treatments to create a cohesive look.
tip

Use FlutterFlow's screenshot generator along with services like Shots.so to create beautiful cover images.

2.10 Image Representativeness​

  • Criteria: Images must accurately reflect the actual content and functionality of your project.
  • Why it Matters: Misleading images create a negative experience for users and erode trust in Marketplace.
  • What To Do:
    • Use genuine screenshots or recordings: Avoid showcasing designs or features that are not actually present in your project.
    • Use abstract images sparingly: While a certain level of abstraction or illustration can be effective for concepts that are hard to capture with screenshots, they should be used judiciously. Prefer to showcase actual product screenshots in your gallery images.

2.11 No FlutterFlow Logo in Images​

  • Criteria: Do not include the FlutterFlow logo in your cover photos.
  • Why it Matters: Using the FlutterFlow logo might suggest an official endorsement or the appearance of an official template, neither of which may be accurate. Additionally, including the logo is redundant, as all items are exclusively offered through the FlutterFlow Marketplace.
  • What To Do: Remove any references to the FlutterFlow logo in your images.

3. Aesthetics & Design​

First impressions matter! We're looking for projects that go beyond basic functionality and demonstrate a strong understanding of visual design principles.

3.1 Design Standard​

  • Criteria: Projects should adhere to high standards of visual design, incorporating principles of usability, accessibility, and aesthetics.
  • Why it Matters: A well-designed app is not just visually appealing; it's intuitive, easy to navigate, and provides a positive user experience.
  • What To Do:
    • Prioritize usability: Make sure your design choices support, rather than hinder, the core functionality of your app.
    • Consider visual hierarchy: Guide the user's eye with clear visual cues – size, color, contrast, and spacing can all be used effectively.
    • Maintain consistency: Aim to use a theme colors and typography throughout your project, as well as consistent padding, list spacing, border radii, and navigation elements.
    • Test with real users: Get feedback from others to identify any areas of your design that are confusing or frustrating to use.

3.2 Screen Size Compatibility (Responsiveness)​

  • Criteria: Projects should be designed to adapt seamlessly to various screen sizes.
  • Why it Matters: Users expect Flutter apps to scale appropriately across a wide range of devices, from small smartphones to large desktop monitors. A responsive design ensures a positive user experience across the board.
  • What To Do:
    • Follow responsive design best practices: Use Wrap, Responsive Visibility, and Flex features to ensure your app can scale across devices. Read more about building responsively in Responsive Layouts: 101.
    • Test on different devices: Use FlutterFlow's different virtual devices in Test and Run Modes to test your project on a variety of screen sizes. Experiment with the canvas size in the builder to check how your designs scale.

4. Test Experience​

A seamless and positive test experience is crucial for users to evaluate your FlutterFlow item before purchasing or cloning. This section focuses on ensuring your submission is functional, accessible, and easy to explore.

  • Criteria: The provided Run Mode link must be active and correctly load a working demo of your project.
  • Why it Matters: The Run Mode link is the primary way users can interact with your project before purchasing. A broken or inaccessible link creates a significant barrier.
  • What To Do:
    • Double-check your link: Before submitting, test the link multiple times to confirm it showcases the experience you want potential buyers to have.

4.2 User Sign-In (Anonymous Auth)​

  • Criteria: Users should be able to explore the core functionality of your item without being required to create an account or log in.
  • Why It Matters: Requiring upfront authentication creates friction for users who simply want to try before they buy. Additionally, forcing users to provide personal information could cause privacy issues. Anonymous authentication allows for immediate exploration.
  • What To Do:
    • Provide pre-filled demo credentials: If your demo relies heavily on user-specific data, consider creating a demo account with pre-populated sample data accessible to guest users. Pre-fill the username and password on the sign in screen so that users can easily begin exploring your item.
    • Implement anonymous authentication: FlutterFlow supports easy integration with Firebase for anonymous sign-in. This allows users to access your project's demo mode without creating an account.
    • Remove authentication: Another option is to remove the need for any authentication altogether. This will enable users to start exploring your item immediately without any barriers.

4.3 Accessible Navigation​

  • Criteria: All pages and sections within your project should be easily navigable and accessible.
  • Why it Matters: A confusing or broken navigation flow creates a frustrating user experience. Users should be able to intuitively explore all aspects of your project.
  • What To Do:
    • Configure the Initial Page Properly: In Settings > App Details, the 'Entry Page' determines the starting point for Run Mode links and the initial page users will see when they enter your app. Make sure this is set to the most logical and welcoming page to ensure a smooth user entry and navigation experience.
    • Review your project's Storyboard view: This view displays the navigation across various pages and can help highlight any gaps. Please note that any page which is not accessible will not be shown.
    • Test navigation thoroughly: Click through every button, link, and menu item in Run Mode to make sure they lead to the correct destinations.

4.4 Functional Template​

  • Criteria: All core features and functionalities within your project must be working correctly.
  • Why it Matters: Broken features or functionalities lead to a negative user experience and give the impression of a rushed or incomplete project.
  • What To Do:
    • Rigorous testing is essential: Test every aspect of your project – from button clicks and form submissions to API calls and animations.
    • Emulate real-world scenarios: Don't just test with ideal data or happy paths. Introduce potential edge cases or user errors to see how your project handles them.
    • Get fresh eyes on it: Ask someone unfamiliar with your project to test it and provide feedback.

5. Build Quality​

Building a solid app template goes beyond surface-level design. It's about creating a robust, efficient, and user-friendly project that can scale and makes efficient use of components. This section focuses on technical excellence and attention to detail.

5.1 Error-Free Functionality​

  • Criteria: Projects should be free of runtime errors, crashes, and unexpected behaviors.
  • Why it Matters: Errors and crashes create a frustrating user experience and can damage the reputation of your project.
  • What To Do:
    • Review project errors and optimizations: Do not submit projects with any errors, and attempt to address most optimization suggestions in the top bar.
    • Use FlutterFlow's debugging tools: Take advantage of FlutterFlow's built-in debugging panel to identify and resolve issues.
    • Handle nulls and errors gracefully: Add default values for variables in case their value is ever null. Implement conditionals in action chains to respond appropriately to API errors or other cases when something goes wrong.

5.2 No Pixel Overflow​

  • Criteria: Ensure your UI elements are positioned and sized correctly to avoid content overflowing its container, leading to visual glitches / cut off content.
  • Why It Matters: Pixel overflows are a sign of UI inconsistencies that can negatively impact the user experience, especially on different screen sizes. Pixel overflow issues can occur in Test Mode when there’s a hardcoded pixel value and not enough space on the screen to render that exact value.
  • What To Do:
    • Preview pixel overflows: Toggle the pixel overflow icon in the top-right of the canvas to see if there are any overflow issues.
    • Leverage FlutterFlow's layout tools: Use Expanded and Flex values to help prevent layout issues. Make Columns or Rows scrollable to prevent overflows. Use auto-sizing text or text clipping where it makes sense. Remove hard-coded width and height where it makes sense.
    • Test on different screen sizes: Resize the canvas while building to preview any potential issues.

5.3 Error-Free Custom Code​

  • Criteria: Any custom code integrated into your project (using Custom Functions, Actions, and Widgets) must be free of syntax errors, logical errors, and potential security vulnerabilities.
  • Why it Matters: Errors in custom code can lead to app instability, crashes, or even security risks.
  • What To Do:
    • Write clean, well-documented code: This makes it easier to debug and maintain your project.
    • Test custom code thoroughly: Isolate and test your custom code units (functions, actions) to ensure they work as expected.
    • Use FlutterFlow's code validation: Pay close attention to any warnings or errors highlighted by FlutterFlow's built-in code validation.

5.4 Coherent & Relevant Custom Code​

  • Criteria: Custom code should be purposefully integrated and enhance your project's functionality in a meaningful way. Avoid unnecessary or redundant code. Avoid including unused or irrelevant custom code.
  • Why it Matters: While custom code offers flexibility, excessive or poorly integrated code can make your project harder to understand, maintain, and update in the future.
  • What To Do:
    • Plan your custom code strategically: Determine if FlutterFlow's built-in features can achieve the desired functionality before resorting to custom code.
    • Comment your code effectively: Explain the purpose and logic behind your custom code to improve readability and maintainability.
    • Keep it modular: Break down complex logic into smaller, reusable functions or actions. Prefer code blocks when a Custom Function is relatively short and will only be used once.

5.5 Testable Custom Code in Run Mode​

  • Criteria: Ensure that the functionality implemented using custom code is accessible and verifiable within the Run Mode demo.
  • Why It Matters: Users should be able to experience the full impact of your custom code item within the Run Mode environment.
  • What To Do:
    • Add a page that uses your custom code: This page should ideally expose the ideal use case of your custom code or perhaps allow users to set and control parameter values in Run Mode.
    • Provide clear instructions: If special steps are required for users to test certain custom code functionalities in Run Mode, explain these instructions clearly within your project description or documentation.

5.6 Proper Firestore Rules (If Applicable)​

  • Criteria: If your project utilizes Firestore as a database, ensure your Firestore Security Rules are correctly configured in Settings to protect user data and prevent unauthorized access.
  • Why it Matters: Improperly configured Firestore Rules can expose sensitive user data or create security vulnerabilities within users' apps.
  • What To Do:
    • Implement Firestore Security Rules: Familiarize yourself with how FlutterFlow exposes Firestore rules and make the necessary modifications in your base project.
    • Test your rules thoroughly: Create test accounts and attempt add, update, and delete operations on your data across different authentication states to verify your rules are working as intended.

5.7 Spelling and Grammar​

  • Criteria: Maintain a professional tone with correct spelling and grammar throughout your project's UI text, descriptions, and documentation.
  • Why it Matters: Even small typos can detract from your project's credibility and create a negative user experience.
  • What To Do:
    • Proofread, proofread, proofread: Carefully review all text elements within your project. Ask a friend or colleague to review your text for errors.

5.8 User-Friendly Template​

  • Criteria: Your template should empower users to build upon it easily and intuitively, regardless of their FlutterFlow expertise.
  • Why It Matters: A user-friendly template increases its value and appeal. When users can quickly understand and customize your template, they're more likely to choose it, leading to greater success for your Marketplace item.
  • What To Do:
    • Embrace reusable components: Design your template with modularity in mind. Create reusable components that users can easily modify for their use case.
    • Clear and concise naming conventions: Use descriptive names for widgets, variables, and functions to make your template's structure understandable at a glance.
    • Logical organization: Structure your template's layout in a clear and logical manner, grouping related elements and using comments to guide users.
    • Documentation is key: Provide clear and comprehensive documentation that guides users on how to use and customize your template effectively. Include explanations of key features, customization options, and potential use cases.
    • Test with diverse users: Get feedback from users with varying levels of FlutterFlow experience. This helps identify potential pain points or areas where your template could be more user-friendly.

5.9 Appropriate State Management​

  • Criteria: Implement state management effectively to ensure data is updated and reflected correctly across your application.
  • Why it Matters: Proper state management is crucial for building responsive and dynamic Flutter apps. It helps prevent data inconsistencies, improves performance, and makes your code easier to maintain.
  • What To Do:
    • Choose the right state management scope: FlutterFlow supports (1) App State (2) Page State and (3) Component State variables. Familiarize yourself with these options and scope any state variables to where they are needed. For instance, do not use App State to control the value of a checkbox within a component.
    • Rebuild efficiently: Ensure changes to state rebuild only the necessary scope for efficiency.

5.10 Organized Widget Tree​

  • Criteria: Maintain a well-structured and organized widget tree within your FlutterFlow project.
  • Why It Matters: A clean and organized widget tree makes your project more understandable, maintainable, and less prone to errors. It also makes it easier for others to collaborate on your project.
  • What To Do:
    • Use descriptive names for widgets and variables: Make your code self-documenting by using clear and meaningful names for major nodes.
    • Avoid deeply nested widgets: If your widget tree becomes too deeply nested (>10 levels), consider breaking it down into smaller, reusable components.

5.11 Follow FlutterFlow Best Practices​

  • Criteria: Adhere to recommended best practices and guidelines for building apps with FlutterFlow.
  • Why It Matters: Following best practices can help you avoid common pitfalls, improve the performance of your app, and ensure your project is compatible with future updates to FlutterFlow.
  • What To Do:
    • Stay up-to-date: Keep an eye on FlutterFlow's official documentation, blog posts, and community forums for the latest tips, tricks, and best practices.
info

Stay tuned for an upcoming "style guide" we're publishing that goes into deeper detail about best practices for building in FlutterFlow.

5.12 Limit Static Images​

  • Criteria: Minimize the use of large, unoptimized static images within your project to prevent app bloat and ensure that your template accurately represents the functionality of your app.
  • Why It Matters: Overusing large static images not only increases the download size and slows down performance, particularly on slower networks, but also risks misleading users. For example, using an image of a map or a credit card form, rather than building these elements, can give the false impression that your app includes functionalities that are merely visual mockups. This can disappoint users when they discover these components are non-interactive.
  • What To Do:
    • Build Functional Components: Wherever possible, replace static images with functional elements built using FlutterFlow. This ensures your app remains scalable and interactive, providing a genuine user experience across all device sizes and orientations.
    • Use optimized images: Reduce image file size using online compression tools, which maintain quality while decreasing load times.
    • Leverage caching: Implement image caching for network images to minimize repeated downloads of the same images, which enhances performance.

5.13 Limit Custom Code (When Possible)​

  • Criteria: While custom code is powerful, strive to achieve as much functionality as possible using FlutterFlow's visual builder and built-in features.
  • Why It Matters: Over-reliance on custom code can make your project less maintainable, less user-friendly, and potentially more prone to errors.
  • What To Do:
    • Explore FlutterFlow's capabilities: Familiarize yourself with FlutterFlow's extensive library of pre-built widgets, actions, and integrations to see if they can fulfill your requirements before resorting to custom code.

5.14 Efficient Component Use & Avoiding Duplication​

  • Criteria: Projects should demonstrate efficient use of FlutterFlow's components. Avoid unnecessary duplication of pages, widgets, or actions. Strive to create reusable components and implement action blocks in a scalable and maintainable way.
  • Why it Matters: Duplicating large sections of code or entire pages with only minor changes bloats the project size, reduces maintainability, and can mislead users about the project's complexity and value.
  • What To Do:
    • Leverage Components: Create reusable components for elements that repeat throughout your project (e.g., product cards, list items, headers, footers).
    • Utilize Parameters: Pass data and customize component instances using parameters instead of duplicating and hardcoding values.
    • Review for Redundancies: Before submitting, carefully examine your project for any unnecessarily duplicated pages, widgets, or action chains that could be consolidated or streamlined.

5.15 Library Values Implementation (Libraries Only)​

  • Criteria: Libraries must use Library Values for sensitive keys and customizable elements that users need to configure.
  • Why It Matters: Library Values allow users to safely provide their own API keys and customize critical configuration without modifying the library's core functionality. This improves security and makes libraries more flexible and reusable.
  • What To Do:
    • Identify Configurable Elements: Review your library for any API keys, endpoints, or other values that users should be able to customize.
    • Create Library Values: Set up Library Values for these configurable elements in Settings > App Settings > Publish as Library.
    • Document Requirements: Clearly explain in your item description if any Library Values are required for your library to function correctly.
    • Test Configuration: Verify that your library functions correctly when Library Values are changed by users.
  • Criteria: Projects should include automated tests that verify core functionality and key user workflows. While not required for approval, this is strongly recommended for libraries and will positively impact visibility.
  • Why It Matters: Automated tests help ensure reliability, catch regressions, and demonstrate your commitment to quality. They also improve your item's visibility.
  • What To Do:
    • Add Integration Tests: Use FlutterFlow's automated testing features to verify your item's core functionality.
    • Test Key Workflows: Focus on testing critical user paths and features that users will rely on.
    • For Libraries: Since libraries are often used as building blocks in larger applications, thorough testing is particularly important to:
      • Verify that Library Values are properly implemented
      • Ensure core functionality works across different configurations
      • Demonstrate expected behavior to potential users
      • Catch issues before they affect downstream applications

6. Value (Paid Items)​

A successful Marketplace item goes beyond just a functional app—it provides real value to users.

6.1 High Value Proposition​

  • Criteria: Items should offer a compelling value proposition that justifies their price.
  • Why It Matters: Users are looking for solutions that save them time, effort, or resources, or that provide a unique experience they can't easily find elsewhere.
  • What To Do:
    • Define Your Unique Value: Identify and articulate what sets your project apart from others. Ensure it solves a specific problem in a way that is not readily available in Marketplace.
    • Tag Appropriately: Accurately categorize your item—whether it's a full app, UI kit, or library—to set the right expectations for potential users.
    • Justify Your Pricing: Make sure the pricing of your item reflects its true value and stands in fair comparison to similar offerings. Ensure it offers enough depth and uniqueness to warrant the minimum price point.
    • For Paid Libraries: Libraries should excel in at least one of these areas:
      • 🧘 Simplifying technical complexity (ease)
      • ⚡️ Enabling quick and seamless integrations (speed)
      • 🎛️ Offering diverse reusable components and features (quantity)
      • 🛠️ Providing robust, reliable functionality (quality)
      • 🙋‍♂️ Addressing specific, high-demand use cases with thoughtful solutions (relevance)

7. Legal & Security​

Building trust in the FlutterFlow Marketplace requires respecting legal boundaries and safeguarding user information. This section covers essential considerations to ensure your project adheres to ethical and legal standards.

7.1 Free of Inappropriate Content​

  • Criteria: Projects must not contain any offensive, discriminatory, or illegal content. This includes, but is not limited to:
    • Hate speech or discrimination
    • Sexually explicit material or pornography
    • Content that promotes violence, illegal activities, or harm to others
  • Why it Matters: Maintaining a safe and inclusive community is paramount. Inappropriate content violates the FlutterFlow Terms of Service and may have legal ramifications.
  • What To Do:
    • Review your content carefully: Ensure all text, images, and other assets align with community standards and legal guidelines.
    • Err on the side of caution: When in doubt, it's best to avoid potentially controversial content.

7.2 Free of Copyrighted Material​

  • Criteria: Projects must not include any unauthorized use of copyrighted material, such as:
    • Images, illustrations, or graphics
    • Music or sound effects
    • Code snippets or libraries — see our docs on Open Source Licenses for details
  • Why it Matters: Using copyrighted material without permission is a legal infringement and can result in serious legal consequences, including DMCA takedown.
  • What To Do: Please review our Legal Guidelines for Creators and Navigating External Licenses for more details.

7.3 Free of Trademarked Material​

  • Criteria: Items must not misuse or infringe upon registered trademarks, including:
    • Brand names
    • Logos
    • Slogans
  • Why it Matters: Trademark infringement can lead to legal disputes and damage the reputation of FlutterFlow Marketplace. Please see our Legal Guidelines for Creators for more details.
  • What To Do: Please review our Legal Guidelines for Creators for more details.

7.4 Free of Confidential Data​

  • Criteria: Projects should not expose any sensitive or confidential information, including:
    • API keys
    • User credentials
    • Personal data (e.g., names, addresses, financial information)
  • Why it Matters: Exposing confidential data can compromise the security of your project and put users at risk.
  • What To Do:
    • Follow API Key Best Practices: Add restrictions, delete unnecessary API keys, and regularly rotate your keys to ensure keys are secured.
    • Require users to provide their own API keys: Use ephemeral, user-provided API keys in calls rather than hardcoding your own keys directly into code.
    • Scrub your project before submission: Double-check your project files and codebase to ensure no confidential information is accidentally included.

Common Rejection Reasons​

To help streamline your submission process, here are some of the most frequent reasons projects are flagged:

We're excited to see the amazing FlutterFlow projects you bring to Marketplace! By following these guidelines, you'll help us maintain a high-quality platform that benefits the entire FlutterFlow community. Let's build something incredible together! 🚀