{"privacy":{"en":"<p class=\"fd-meta\">Last updated: January 2026 — UK GDPR · EU GDPR · CCPA/CPRA · PIPEDA · LGPD</p>\n<p>At FrancoDeal (\"we\", \"our\" or \"us\"), we are committed to protecting your personal information and your right to privacy. This privacy policy describes how your personal information is collected, used and shared when you use our services on studio.francodeal.com and francodeal.com.</p>\n<p>This policy complies with the UK GDPR (UK General Data Protection Regulation) and the UK Data Protection Act 2018, the European Union General Data Protection Regulation (GDPR), the California Consumer Privacy Act (CCPA/CPRA), Canada's Personal Information Protection and Electronic Documents Act (PIPEDA), and Brazil's Lei Geral de Proteção de Dados (LGPD).</p>\n<p>For users in other jurisdictions: we are also committed to complying with all applicable personal data protection laws in your country of residence.</p>\n<h3>1. When and how we collect your data</h3>\n<p>We collect personal information in the following situations:</p>\n<ul><li><b>Account creation:</b> when you register for our services via email, Google or LinkedIn</li><li><b>Use of services:</b> when you use our AI content generation services (videos, images, music, voice)</li><li><b>Content upload:</b> when you upload images, videos or audio files for processing</li><li><b>Transactions:</b> when you make a purchase or subscribe</li><li><b>Communication:</b> when you contact our support team</li><li><b>Browsing:</b> automatically while you browse our site</li></ul>\n<h3>2. Types of data collected</h3>\n<ul><li><b>Identification data:</b> first name, last name, email address, phone number</li><li><b>Account data:</b> user ID, password (encrypted), preferences, history</li><li><b>Payment data:</b> billing information, transaction history</li><li><b>Content data:</b> images, videos, audio files you upload or generate</li><li><b>Communication data:</b> messages, support requests, user feedback</li><li><b>Technical data:</b> IP address, browser type, operating system, pages visited</li><li><b>Location data:</b> country, region (determined by IP address)</li></ul>\n<h3>3. Legal basis for processing (GDPR)</h3>\n<ul><li><b>Consent:</b> for cookies, marketing and optional communications</li><li><b>Performance of contract:</b> to provide our services and process your orders</li><li><b>Legal obligations:</b> for accounting, tax and regulatory compliance</li><li><b>Legitimate interests:</b> to improve our services, security and fraud prevention</li></ul>\n<h3>4. Purposes of processing</h3>\n<ul><li>Create and manage your account</li><li>Provide and improve our services</li><li>Process your payments and manage your billing</li><li>Send you support communications</li><li>Analyze the use of our services</li><li>Detect and prevent fraud</li><li>Comply with our legal obligations</li></ul>\n<h3>5. Data sharing and disclosure</h3>\n<p>We share your personal data only in the following cases:</p>\n<ul><li><b>Service providers:</b> hosting, payment, customer support, analytics</li><li><b>Technology partners:</b> AI generation APIs</li><li><b>Legal obligations:</b> if required by law or a competent authority</li><li><b>Protection of rights:</b> to protect our rights, your security or that of others</li></ul>\n<h3>6. Hosting and infrastructure</h3>\n<ul><li><b>Manus:</b> cloud platform for hosting the application</li><li><b>Cloudflare:</b> CDN and security services</li><li><b>AWS/R2:</b> storage of generated content</li></ul>\n<p>These providers comply with international security standards and data protection regulations.</p>\n<h3>7. International data transfers</h3>\n<p>Your data may be transferred and processed in countries outside the EU, notably the United States. We use appropriate protection mechanisms: Standard Contractual Clauses (SCC), adequacy decisions, explicit consent.</p>\n<h3>8. Data security</h3>\n<ul><li>SSL/TLS encryption in transit</li><li>Encryption of sensitive data at rest</li><li>Multi-factor authentication (MFA)</li><li>Role-based access control</li><li>Regular security audits</li><li>ISO 27001 compliance</li></ul>\n<h3>9. Data retention</h3>\n<table><tr><td><b>Data type</b></td><td><b>Retention period</b></td></tr><tr><td>Account data</td><td>Duration of business relationship + 3 years</td></tr><tr><td>Generated content (images, videos, music)</td><td>3 years</td></tr><tr><td>Billing data</td><td>10 years (legal obligation)</td></tr><tr><td>Connection logs</td><td>1 year</td></tr><tr><td>Analytics cookies</td><td>13 months maximum</td></tr></table>\n<p><b>Important:</b> Images, videos, music and other content generated by our AI services are kept for 3 years. You can access your creations at any time from your history.</p>\n<h3>10. Cookies and tracking technologies</h3>\n<ul><li><b>Essential cookies:</b> necessary for the site to function</li><li><b>Analytics cookies:</b> to understand how you use our services</li><li><b>Marketing cookies:</b> to offer you personalized content</li></ul>\n<p>You can control cookies through your browser settings or our consent banner.</p>\n<h3>11. Your rights (GDPR - European Union)</h3>\n<ul><li><b>Right of access:</b> access your personal data</li><li><b>Right of rectification:</b> correct inaccurate data</li><li><b>Right to erasure:</b> request deletion of your data</li><li><b>Right to restriction:</b> restrict processing of your data</li><li><b>Right to portability:</b> receive your data in a structured format</li><li><b>Right to object:</b> object to processing of your data</li></ul>\n<h3>12. Your rights (CCPA/CPRA - California)</h3>\n<ul><li>Right to know personal information collected</li><li>Right to delete personal information</li><li>Right to opt out of the sale of your data</li><li>Right to non-discrimination</li></ul>\n<h3>13. Your rights (PIPEDA - Canada)</h3>\n<ul><li>Right to access your personal information</li><li>Right to request a correction</li><li>Right to know how your data is used</li></ul>\n<h3>14. Your rights (LGPD - Brazil)</h3>\n<ul><li>Right to confirmation of the existence of processing</li><li>Right to access your data</li><li>Right to correction of inaccurate data</li><li>Right to anonymization</li></ul>\n<h3>15. Compliance with Google API Services</h3>\n<p>We use Google API services in accordance with the Google Privacy Policy and Terms of Service. Your data is processed according to Google's standards.</p>\n<h3>16. Protection of minors</h3>\n<p>Our services are not intended for persons under 18 years of age. We do not knowingly collect personal data from minors. If we discover that we have collected data from a minor, we will delete it immediately.</p>\n<h3>17. Automated decisions and profiling</h3>\n<p>We use automated processes to detect fraud and abuse, improve our services, and personalize your experience. You have the right to request a manual review of any automated decision that affects you.</p>\n<h3>18. Changes to this policy</h3>\n<p>We may modify this privacy policy at any time. Changes will be posted on this page with an update date. Your continued use of our services after the changes are posted constitutes your acceptance of the changes.</p>\n<h3>19. Contact us</h3>\n<p>For any questions about this privacy policy or to exercise your rights, contact us:</p>\n<p>Engravethevision LLP (FrancoDeal)<br>Email: info@francodeal.com<br>Address: 71-75 Shelton Street, Covent Garden, London, United Kingdom, WC2H 9JQ<br>Response time: 24-48 hours</p>\n<h3>20. Data controller</h3>\n<p>Engravethevision LLP<br>71-75 Shelton Street, Covent Garden, London, United Kingdom, WC2H 9JQ<br>Email: info@francodeal.com</p>\n<p class=\"fd-meta\">© 2026 FrancoDeal (Engravethevision LLP). All rights reserved.</p>","fr":"<p class=\"fd-meta\">Dernière mise à jour : Janvier 2026 — UK GDPR · RGPD (UE) · CCPA/CPRA · PIPEDA · LGPD</p>\n<p>Chez FrancoDeal (« nous », « notre » ou « nos »), nous nous engageons à protéger vos informations personnelles et votre droit à la vie privée. Cette politique de confidentialité décrit comment vos informations personnelles sont collectées, utilisées et partagées lorsque vous utilisez nos services sur studio.francodeal.com et francodeal.com.</p>\n<p>Cette politique est conforme au UK GDPR et au Data Protection Act 2018 du Royaume-Uni, au RGPD de l'Union Européenne, au California Consumer Privacy Act (CCPA/CPRA), à la PIPEDA du Canada, et à la LGPD du Brésil.</p>\n<p>Pour les utilisateurs d'autres juridictions : nous nous engageons également à respecter toutes les lois applicables en matière de protection des données personnelles dans votre pays de résidence.</p>\n<h3>1. Quand et comment collectons-nous vos données</h3>\n<ul><li><b>Création de compte :</b> lorsque vous vous inscrivez via email, Google ou LinkedIn</li><li><b>Utilisation des services :</b> lorsque vous utilisez nos services de génération IA (vidéos, images, musique, voix)</li><li><b>Téléchargement de contenu :</b> lorsque vous téléchargez des images, vidéos ou fichiers audio</li><li><b>Transactions :</b> lorsque vous effectuez un achat ou souscrivez à un abonnement</li><li><b>Communication :</b> lorsque vous communiquez avec notre support</li><li><b>Navigation :</b> automatiquement lors de votre navigation</li></ul>\n<h3>2. Types de données collectées</h3>\n<ul><li><b>Données d'identification :</b> nom, prénom, email, numéro de téléphone</li><li><b>Données de compte :</b> identifiant, mot de passe (crypté), préférences, historique</li><li><b>Données de paiement :</b> informations de facturation, historique des transactions</li><li><b>Données de contenu :</b> images, vidéos, fichiers audio uploadés ou générés</li><li><b>Données de communication :</b> messages, requêtes de support, retours</li><li><b>Données techniques :</b> adresse IP, navigateur, système d'exploitation, pages visitées</li><li><b>Données de localisation :</b> pays, région (par adresse IP)</li></ul>\n<h3>3. Base légale du traitement (RGPD)</h3>\n<ul><li><b>Consentement :</b> pour les cookies, le marketing et les communications optionnelles</li><li><b>Exécution du contrat :</b> pour fournir nos services et traiter vos commandes</li><li><b>Obligations légales :</b> pour la comptabilité, la fiscalité et la conformité</li><li><b>Intérêts légitimes :</b> pour améliorer nos services, la sécurité et la prévention de la fraude</li></ul>\n<h3>4. Finalités du traitement</h3>\n<ul><li>Créer et gérer votre compte</li><li>Fournir et améliorer nos services</li><li>Traiter vos paiements et gérer votre facturation</li><li>Vous envoyer des communications de support</li><li>Analyser l'utilisation de nos services</li><li>Détecter et prévenir les fraudes</li><li>Respecter nos obligations légales</li></ul>\n<h3>5. Partage et divulgation des données</h3>\n<ul><li><b>Prestataires de services :</b> hébergement, paiement, support client, analytics</li><li><b>Partenaires technologiques :</b> API de génération d'IA</li><li><b>Obligations légales :</b> si requises par la loi ou une autorité compétente</li><li><b>Protection des droits :</b> pour protéger nos droits, votre sécurité ou celle d'autrui</li></ul>\n<h3>6. Hébergement et infrastructure</h3>\n<ul><li><b>Manus :</b> plateforme cloud pour l'hébergement de l'application</li><li><b>Cloudflare :</b> CDN et services de sécurité</li><li><b>AWS/R2 :</b> stockage des contenus générés</li></ul>\n<p>Ces prestataires respectent les normes de sécurité internationales et les réglementations de protection des données.</p>\n<h3>7. Transferts internationaux de données</h3>\n<p>Vos données peuvent être transférées et traitées dans des pays en dehors de l'UE, notamment aux États-Unis. Nous utilisons des mécanismes de protection appropriés : Clauses contractuelles types (SCC), décisions d'adéquation, consentement explicite.</p>\n<h3>8. Sécurité des données</h3>\n<ul><li>Chiffrement SSL/TLS en transit</li><li>Chiffrement des données sensibles au repos</li><li>Authentification multi-facteurs (MFA)</li><li>Contrôle d'accès basé sur les rôles</li><li>Audits de sécurité réguliers</li><li>Conformité aux normes ISO 27001</li></ul>\n<h3>9. Conservation des données</h3>\n<table><tr><td><b>Type de données</b></td><td><b>Durée de conservation</b></td></tr><tr><td>Données de compte</td><td>Durée de la relation commerciale + 3 ans</td></tr><tr><td>Contenus générés (images, vidéos, musique)</td><td>3 ans</td></tr><tr><td>Données de facturation</td><td>10 ans (obligation légale)</td></tr><tr><td>Logs de connexion</td><td>1 an</td></tr><tr><td>Cookies analytiques</td><td>13 mois maximum</td></tr></table>\n<p><b>Important :</b> Les images, vidéos, musiques et autres contenus générés par nos services d'IA sont conservés pendant 3 ans. Vous pouvez accéder à vos créations à tout moment depuis votre historique.</p>\n<h3>10. Cookies et technologies de suivi</h3>\n<ul><li><b>Cookies essentiels :</b> nécessaires pour le fonctionnement du site</li><li><b>Cookies analytiques :</b> pour comprendre comment vous utilisez nos services</li><li><b>Cookies de marketing :</b> pour vous proposer du contenu personnalisé</li></ul>\n<p>Vous pouvez contrôler les cookies via les paramètres de votre navigateur ou notre bandeau de consentement.</p>\n<h3>11. Vos droits (RGPD - Union Européenne)</h3>\n<ul><li><b>Droit d'accès :</b> accéder à vos données personnelles</li><li><b>Droit de rectification :</b> corriger vos données inexactes</li><li><b>Droit à l'oubli :</b> demander la suppression de vos données</li><li><b>Droit à la limitation :</b> limiter le traitement de vos données</li><li><b>Droit à la portabilité :</b> recevoir vos données dans un format structuré</li><li><b>Droit d'opposition :</b> vous opposer au traitement de vos données</li></ul>\n<h3>12. Vos droits (CCPA/CPRA - Californie)</h3>\n<ul><li>Droit de connaître les informations personnelles collectées</li><li>Droit de supprimer les informations personnelles</li><li>Droit de refuser la vente de vos données</li><li>Droit à la non-discrimination</li></ul>\n<h3>13. Vos droits (PIPEDA - Canada)</h3>\n<ul><li>Droit d'accès à vos informations personnelles</li><li>Droit de demander une correction</li><li>Droit de connaître l'utilisation de vos données</li></ul>\n<h3>14. Vos droits (LGPD - Brésil)</h3>\n<ul><li>Droit de confirmation de l'existence de traitement</li><li>Droit d'accès à vos données</li><li>Droit de correction de données inexactes</li><li>Droit à l'anonymisation</li></ul>\n<h3>15. Conformité avec les services API de Google</h3>\n<p>Nous utilisons les services API de Google conformément à la politique de confidentialité de Google et aux conditions d'utilisation. Vos données sont traitées selon les normes de Google.</p>\n<h3>16. Protection des mineurs</h3>\n<p>Nos services ne sont pas destinés aux personnes de moins de 18 ans. Nous ne collectons pas intentionnellement de données personnelles auprès de mineurs. Si nous découvrons que nous avons collecté des données d'un mineur, nous les supprimerons immédiatement.</p>\n<h3>17. Décisions automatisées et profilage</h3>\n<p>Nous utilisons des processus automatisés pour détecter les fraudes et les abus, améliorer nos services et personnaliser votre expérience. Vous avez le droit de demander une révision manuelle de toute décision automatisée qui vous affecte.</p>\n<h3>18. Modifications de cette politique</h3>\n<p>Nous pouvons modifier cette politique de confidentialité à tout moment. Les modifications seront publiées sur cette page avec une date de mise à jour. Votre utilisation continue de nos services après la publication des modifications constitue votre acceptation.</p>\n<h3>19. Nous contacter</h3>\n<p>Engravethevision LLP (FrancoDeal)<br>Email : info@francodeal.com<br>Adresse : 71-75 Shelton Street, Covent Garden, London, United Kingdom, WC2H 9JQ<br>Temps de réponse : 24-48 heures</p>\n<h3>20. Responsable du traitement</h3>\n<p>Engravethevision LLP<br>71-75 Shelton Street, Covent Garden, London, United Kingdom, WC2H 9JQ<br>Email : info@francodeal.com</p>\n<p class=\"fd-meta\">© 2026 FrancoDeal (Engravethevision LLP). Tous droits réservés.</p>"},"legal":{"en":"<p class=\"fd-meta\">Last updated: January 2026</p>\n<h3>I. Approval and acceptance</h3>\n<p>If you have chosen to use the services provided on the FrancoDeal sites (studio.francodeal.com or francodeal.com), this means you approve of and accept these Legal Notices, the Terms of Use, the Privacy Policy, as well as the applicable legal and regulatory provisions.</p>\n<p>Please note that these documents may be updated periodically. It is therefore your responsibility to consult these pages regularly to be aware of any updates. If you do not agree with these conditions, do not use these services.</p>\n<h3>II. Intellectual property policy</h3>\n<p>All elements making up and integrated into the FrancoDeal sites are the exclusive property of FrancoDeal (a brand of Engravethevision LLP), including but not limited to:</p>\n<ul><li>Logos and visual identity</li><li>Images, graphics and illustrations</li><li>Texts and editorial content</li><li>Databases</li><li>Videos and multimedia content</li><li>Photographs</li><li>Names, trademarks and distinctive signs</li><li>Source code and technical architecture</li></ul>\n<p>Exception is made for elements created by external contributors who have not transferred their copyrights, as well as for content generated by users via our AI services.</p>\n<p><b>Important:</b> Any individual browsing FrancoDeal agrees not to reproduce, copy, modify, distribute or use the data that composes it, regardless of its nature, without prior written authorization from FrancoDeal.</p>\n<h3>III. Right to image and privacy</h3>\n<p>Any FrancoDeal user who uploads or uses on the site the image of a person, or content likely to infringe a person's privacy, must have obtained their express prior authorization.</p>\n<p>It is strictly forbidden to upload or use on the site the image of a person without their authorization, including if they are a celebrity or public figure. By using our AI content generation services (avatars, videos, images), you certify that you have all necessary rights to the content you submit, in particular the image rights of the persons represented.</p>\n<h3>IV. Site publisher</h3>\n<h4>Registered office (United Kingdom)</h4>\n<p>Engravethevision LLP — FrancoDeal is a brand of Engravethevision LLP<br>71-75 Shelton Street, Covent Garden, London, United Kingdom, WC2H 9JQ</p>\n<h4>Domiciliation (Canada)</h4>\n<p>Engravethevision LLP — Nova Scotia, Canada<br>GST/HST Number: 766879555RT0001</p>\n<p>Email: info@francodeal.com · Website: francodeal.com<br>Publication director: Engravethevision LLP</p>\n<h3>V. Hosting</h3>\n<h4>FrancoDeal Studio (Web Application)</h4>\n<p>Hosted by Manus (a brand of META Platforms, Inc.), 1 Hacker Way, Menlo Park, CA 94025, USA — manus.im. Services: secure cloud hosting, user authentication (OAuth, session management), generative AI access, temporary storage of generated files (7 days).</p>\n<h4>FrancoDeal Collections and FrancoDeal Magazine</h4>\n<p>Hosted by Hostinger International Ltd., 61 Lordou Vironos Street, 6023 Larnaca, Cyprus — registration HE 330877, hostinger.com. Services: web hosting, SSL certificates, professional email, optimized WordPress hosting. Data is stored on secure servers with industry-standard and GDPR-compliant protection measures.</p>\n<h3>VI. Retention of generated data</h3>\n<p><b>Retention period:</b> Content generated by our AI services (images, videos, music, voice) is kept on our servers for 7 days from creation. After this period, files are automatically deleted. It is therefore your responsibility to download and save your creations before this deadline.</p>\n<h3>VII. Credits and technologies</h3>\n<p>FrancoDeal uses: React, Tailwind CSS, Node.js. Payment services: Stripe, Inc. Icons from Lucide Icons.</p>\n<h3>VIII. Third-party trademarks, brands and referencing</h3><p>The FrancoDeal ecosystem comprises three services: <strong>FrancoDeal Magazine</strong> (multilingual editorial publication), <strong>FrancoDeal Collections</strong> (editorial discovery and referencing platform) and <strong>FrancoDeal Studio</strong> (AI-powered creative studio, studio.francodeal.com).</p><p>FrancoDeal Collections operates as an editorial discovery and listing platform. All third-party trademarks, trade names, logos, visuals and properties mentioned on the FrancoDeal sites remain the exclusive property of their respective owners. Unless expressly stated otherwise on a specific listing or content (e.g. “Official Partner” or “In affiliation with”), no affiliation, endorsement or sponsorship is claimed or implied.</p><p>Editorial content and listings are provided for informational purposes only and, unless expressly presented as commercial offers with their own terms and conditions, do not constitute a commercial offer. Establishments may request a correction, an update or the removal of a listing by writing to info@francodeal.com; requests are handled promptly.</p><h3>IX. Jurisdiction – Applicable law</h3>\n<p>These legal notices are subject to the laws applicable in the jurisdictions where Engravethevision LLP is established and operates, in particular: United Kingdom (UK GDPR and Data Protection Act 2018), European Union (GDPR), Canada (PIPEDA), and all applicable data protection and e-commerce laws.</p>\n<p><b>Disputes:</b> Any dispute arising regarding these Legal Notices will first be subject to an amicable settlement attempt between the parties. These terms are subject to the London (UK) civil procedure code. Failing an amicable solution, express jurisdiction is granted to the competent courts of the United Kingdom.</p>\n<p><b>Mediation:</b> In accordance with applicable legal provisions, in the event of a dispute, you may use a conventional mediation procedure or any other alternative dispute resolution method.</p>\n<p class=\"fd-meta\">© 2026 FrancoDeal (Engravethevision LLP). All rights reserved.</p>","fr":"<p class=\"fd-meta\">Dernière mise à jour : Janvier 2026</p>\n<h3>I. Approbation et adhésion</h3>\n<p>Si vous avez fait le choix d'utiliser les services fournis sur le site studio.francodeal.com ou francodeal.com (ci-après « FrancoDeal »), cela signifie que vous approuvez et adhérez aux présentes Mentions Légales, aux Conditions Générales d'Utilisation (CGU), à la Politique de Confidentialité, ainsi qu'aux dispositions légales et réglementaires en vigueur.</p>\n<p>Veuillez noter que ces documents pourront être mis à jour périodiquement. Il relève donc de votre responsabilité de consulter régulièrement ces pages afin de prendre connaissance de toute actualisation. Si vous désapprouvez ces conditions, n'adhérez pas à ces services.</p>\n<h3>II. Politique relative à la propriété intellectuelle</h3>\n<p>Tous les éléments constituant et intégrant les sites FrancoDeal sont la propriété exclusive de FrancoDeal (marque de Engravethevision LLP), incluant mais sans s'y limiter :</p>\n<ul><li>Logos et identité visuelle</li><li>Images, graphismes et illustrations</li><li>Textes et contenus éditoriaux</li><li>Bases de données</li><li>Vidéos et contenus multimédias</li><li>Photographies</li><li>Noms, marques et signes distinctifs</li><li>Code source et architecture technique</li></ul>\n<p>Exception est faite pour les éléments réalisés par des intervenants extérieurs n'ayant pas cédé leurs droits d'auteurs, ainsi que pour les contenus générés par les utilisateurs via nos services d'IA.</p>\n<p><b>Important :</b> Tout individu naviguant sur FrancoDeal s'engage à ne pas reproduire, copier, modifier, distribuer ou utiliser les données qui le composent, quelle que soit leur nature, sans autorisation préalable écrite de FrancoDeal.</p>\n<h3>III. Droit à l'image et vie privée</h3>\n<p>Tout utilisateur de FrancoDeal qui télécharge ou utilise sur le site l'image d'une personne, ou un contenu susceptible de porter atteinte à la vie privée d'une personne, doit avoir obtenu au préalable son autorisation expresse.</p>\n<p>Il est strictement interdit de télécharger ou utiliser sur le site l'image d'une personne sans son autorisation, y compris si elle est une célébrité ou une personne publique. En utilisant nos services de génération de contenu IA (avatars, vidéos, images), vous certifiez disposer de tous les droits nécessaires sur les contenus que vous soumettez, notamment les droits à l'image des personnes représentées.</p>\n<h3>IV. Éditeur du site</h3>\n<h4>Siège social (Royaume-Uni)</h4>\n<p>Engravethevision LLP — FrancoDeal est une marque de Engravethevision LLP<br>71-75 Shelton Street, Covent Garden, London, United Kingdom, WC2H 9JQ</p>\n<h4>Domiciliation (Canada)</h4>\n<p>Engravethevision LLP — Nouvelle-Écosse, Canada<br>Numéro TPS/TVH : 766879555RT0001</p>\n<p>Email : info@francodeal.com · Site web : francodeal.com<br>Directeur de la publication : Engravethevision LLP</p>\n<h3>V. Hébergement</h3>\n<h4>FrancoDeal Studio (Application Web)</h4>\n<p>Hébergé par Manus (marque de META Platforms, Inc.), 1 Hacker Way, Menlo Park, CA 94025, États-Unis — manus.im. Services : hébergement cloud sécurisé, authentification utilisateur (OAuth, gestion des sessions), IA générative, stockage temporaire des fichiers générés (7 jours).</p>\n<h4>FrancoDeal Collections et FrancoDeal Magazine</h4>\n<p>Hébergé par Hostinger International Ltd., 61 Lordou Vironos Street, 6023 Larnaca, Chypre — enregistrement HE 330877, hostinger.fr. Services : hébergement web, certificats SSL, messagerie professionnelle, hébergement WordPress optimisé. Les données sont stockées sur des serveurs sécurisés conformes aux normes de l'industrie et au RGPD.</p>\n<h3>VI. Conservation des données générées</h3>\n<p><b>Durée de conservation :</b> Les contenus générés par nos services d'IA (images, vidéos, musiques, voix) sont conservés sur nos serveurs pendant 7 jours à compter de leur création. Passé ce délai, les fichiers sont automatiquement supprimés. Il est de votre responsabilité de télécharger et sauvegarder vos créations avant l'expiration de ce délai.</p>\n<h3>VII. Crédits et technologies</h3>\n<p>FrancoDeal utilise : React, Tailwind CSS, Node.js. Services de paiement : Stripe, Inc. Les icônes proviennent de Lucide Icons.</p>\n<h3>VIII. Marques de tiers et référencement</h3><p>L’écosystème FrancoDeal comprend trois services : <strong>FrancoDeal Magazine</strong> (publication éditoriale multilingue), <strong>FrancoDeal Collections</strong> (plateforme éditoriale de découverte et de référencement) et <strong>FrancoDeal Studio</strong> (studio créatif propulsé par l’IA, studio.francodeal.com).</p><p>FrancoDeal Collections agit comme plateforme éditoriale de découverte et de référencement. Les marques, noms commerciaux, logos, visuels et propriétés de tiers mentionnés sur les sites FrancoDeal demeurent la propriété exclusive de leurs détenteurs respectifs. Sauf indication contraire explicite sur une fiche ou un contenu (par exemple « Partenaire officiel » ou « En affiliation avec »), aucune affiliation, approbation ou parrainage n’est revendiqué ni suggéré.</p><p>Les contenus éditoriaux et fiches sont fournis à titre informatif et, sauf s’ils sont expressément présentés comme des offres commerciales avec leurs propres conditions, ne constituent pas une offre commerciale. Tout établissement peut demander une correction, une mise à jour ou le retrait d’une fiche en écrivant à info@francodeal.com ; les demandes sont traitées rapidement.</p><h3>IX. Attribution de juridiction – Loi applicable</h3>\n<p>Les présentes mentions légales sont soumises aux lois applicables dans les juridictions où Engravethevision LLP est établie et opère, notamment : Royaume-Uni (UK GDPR et Data Protection Act 2018), Union européenne (RGPD), Canada (PIPEDA), et toutes les lois applicables en matière de protection des données et de commerce électronique.</p>\n<p><b>Litiges :</b> Tout litige fera l'objet d'une tentative de règlement amiable. Les présentes conditions sont soumises au code de procédure civile de Londres au Royaume-Uni. Après échec d'une solution amiable, compétence expresse est attribuée aux tribunaux compétents du Royaume-Uni.</p>\n<p><b>Médiation :</b> Conformément aux dispositions légales en vigueur, en cas de litige, vous pouvez recourir à une procédure de médiation conventionnelle ou à tout autre mode alternatif de règlement des différends.</p>\n<p class=\"fd-meta\">© 2026 FrancoDeal (Engravethevision LLP). Tous droits réservés.</p>"},"terms":{"en":"<p class=\"fd-meta\">Last updated: January 2026</p>\n<p>If you have chosen to use the services provided on the FrancoDeal site (studio.francodeal.com and francodeal.com), this means you approve of and accept these Terms of Use as well as the applicable legal and regulatory provisions. These may be updated periodically; it is your responsibility to consult this page regularly. If you do not agree with these conditions, do not use these services.</p>\n<h3>I. Description of Services</h3>\n<p>FrancoDeal is a service platform for luxury professionals. The ecosystem currently comprises three main services: <strong>FrancoDeal Magazine</strong>, a multilingual editorial magazine; <strong>FrancoDeal Collections</strong>, an editorial discovery and referencing platform; and <strong>FrancoDeal Studio</strong>, described below.</p>\n<h4>FrancoDeal Studio (studio.francodeal.com)</h4>\n<ul><li>Video generation from text or images</li><li>AI image generation and editing</li><li>Talking AI avatar creation</li><li>Video editing tools with audio synchronization</li><li>AI music and voice generation</li><li>Multimedia translation</li></ul>\n<h4>FrancoDeal Collections (francodeal.com)</h4>\n<p>A private directory reserved for luxury professionals in specific categories (see section XIV).</p>\n<p><b>Important:</b> The Service is provided \"as is\" without warranty of being error-free or uninterrupted. For more information about our plans and pricing, see our Plans page.</p>\n<h3>II. Intellectual Property</h3>\n<p>All elements making up the FrancoDeal sites are the exclusive property of FrancoDeal (a brand of Engravethevision LLP), including logos, images, graphics, texts, content, databases, videos, photographs, names, trademarks, source code and technical architecture. Exception is made for elements created by external contributors who have not transferred their copyrights, and for content generated by users via our AI services.</p>\n<p><b>Important:</b> Any individual browsing FrancoDeal agrees not to reproduce, copy, modify, distribute or use the data that composes it without prior written authorization.</p>\n<h3>III. Right to Image and Privacy</h3>\n<p>Any FrancoDeal user who publishes or uses on the site the image of a person or content likely to infringe their privacy must have obtained their express prior authorization. It is strictly forbidden to use the image of a person without their authorization, including if they are a celebrity or public figure. By using our AI generation services, you certify that you have all necessary rights to the content you submit.</p>\n<h3>IV. Rules of Conduct</h3>\n<p>The following are prohibited on FrancoDeal sites:</p>\n<ul><li>Using its services if you are a minor</li><li>Sharing confidential personal data in publication fields meant for users</li><li>Using international money transfer services (Western Union, MoneyGram, etc.) between users</li><li>Using its services for illegal purposes</li><li>Any reference to the occult or related sciences</li><li>Publishing content contrary to public decency and order</li><li>Constituting a criminal offense (defamatory, negationist, insulting, racist, obscene, homophobic, pedophilic, sexual, pornographic content, incitement to murder/suicide, etc.)</li><li>Any form of fraud, breach of trust or abuse of weakness</li><li>Usurping users' information</li><li>Counterfeiting or unauthorized reproduction of a work of the mind</li><li>Copying and modifying the data composing the site</li><li>Harming the interests and property of FrancoDeal and its users</li><li>Reporting abuse without justification</li><li>Distributing spam, chain emails or pyramid schemes</li><li>Publishing hyperlinks to prohibited or illegal content</li><li>Publishing competitive content (except for FrancoDeal collaborators)</li></ul>\n<h3>V. Protection of Personal Data</h3>\n<p>This site allows you to access and rectify information concerning you by contacting info@francodeal.com. For legitimate reasons, you may object to the processing of your personal data. For more details, see our Privacy Policy.</p>\n<h3>VI. Responsibilities and Disclaimer</h3>\n<p>FrancoDeal does not guarantee: the authenticity and accuracy of information provided by members; the absence of misuse by third parties; the absence of errors or interruptions in cases of force majeure; that personal information provided by the user is complete, current and correct.</p>\n<p>FrancoDeal disclaims all liability in case of abnormal use, illicit exploitation, loss of password, identity theft, attack or hacking. Data published by users is the sole responsibility of their authors.</p>\n<p><b>Limitation of liability:</b> Our total liability does not exceed the amount you have paid over the last 12 months.</p>\n<h3>VII. Use of Cookies</h3>\n<p>To facilitate navigation, cookies may be placed on your computer, for example to retain search criteria and your language preferences. You can set your browser to refuse them. For more information, see our Privacy Policy.</p>\n<h3>VIII. Penalties</h3>\n<p>In case of non-compliance with the Terms of Use, FrancoDeal reserves the right to: issue warnings, temporarily or indefinitely suspend an account, delete information, block an IP address, or impose any other appropriate sanction. FrancoDeal may inform the competent authorities of any distribution contrary to public order, decency and applicable laws.</p>\n<h3>IX. Termination Conditions</h3>\n<p>You may cancel your registration at any time in your account or by contacting info@francodeal.com. Services remain active as long as payments are made. If you choose a monthly subscription and stop paying, your services will be interrupted.</p>\n<p><b>Access after cancellation:</b> Your subscription remains active until the end of the current billing period. Remaining credits stay valid until the end of your subscription period. After expiration, all unused credits are lost.</p>\n<h3>X. Pricing and Subscriptions</h3>\n<p>We offer several monthly and annual subscription plans for luxury professionals. Each plan includes a number of credits to generate content. Subscription fees are charged automatically each month or year. Your subscription renews automatically. Unused credits are not refunded and do not roll over. Credits cannot be exchanged for cash.</p>\n<h3>XI. Payment Terms</h3>\n<h4>11.1 Payment Processor</h4>\n<p>Payment by bank card via the secure Stripe interface. All payments are encrypted and secured (PCI DSS Level 1). We never have access to your credit card information.</p>\n<h4>11.2 GST/HST Number</h4><p>766879555RT0001</p>\n<h4>11.3 Failed Payments</h4>\n<p>If your payment fails, we will send an email notification. You have 3 days to update your payment method. After 3 days, your subscription will be suspended.</p>\n<h3>XII. Refund Policy</h3>\n<p><b>General principle:</b> No refund is possible after the service has been performed.</p>\n<p><b>Refund period:</b> You may request a full refund within 7 days of your initial purchase. After this period, no refund can be granted.</p>\n<p><b>Eligibility conditions:</b> request submitted within 7 days of initial purchase; no credits used (0% usage); account in good standing; first refund request on this account.</p>\n<p><b>Processing fee:</b> A 7% processing fee applies to refunds (Stripe fees, administrative and banking fees).</p>\n<p><b>Non-eligible cases:</b> requests after 7 days; credits used (even partially); subscription renewals; plan changes; violations of the terms of use.</p>\n<p><b>How to request:</b> email info@francodeal.com with your order number, purchase date and account email.</p>\n<h3>XIII. Ambassador Program</h3>\n<p>Ambassadors receive a commission based on sales generated through their referral link. Commissions vary according to the type of plan subscribed by the referred user.</p>\n<h3>XIV. Jurisdiction – Applicable Law</h3>\n<p>Any dispute will first be subject to an amicable settlement attempt. These general terms are subject to the London (UK) civil procedure code.</p>\n<p>Engravethevision LLP<br>71-75 Shelton Street, Covent Garden, London, United Kingdom, WC2H 9JQ</p>\n<h3>XV. Contact and Support</h3>\n<p>Engravethevision LLP (FrancoDeal)<br>Email: info@francodeal.com · Response time: 24-48 hours · Website: francodeal.com</p>\n<p class=\"fd-meta\">Legal compliance: These terms comply with US federal laws (FTC Click-to-Cancel Rule), EU laws (14-day withdrawal), Canadian laws (PIPEDA), UK laws (UK GDPR) and Stripe terms.</p>\n<p class=\"fd-meta\">© 2026 FrancoDeal (Engravethevision LLP). All rights reserved.</p>","fr":"<p class=\"fd-meta\">Dernière mise à jour : Janvier 2026</p>\n<p>Si vous avez fait le choix d'utiliser les services fournis sur le site FrancoDeal (studio.francodeal.com et francodeal.com), cela signifie que vous approuvez et adhérez aux présentes Conditions d'utilisation ainsi qu'aux dispositions légales et réglementaires en vigueur. Celles-ci pourront être mises à jour périodiquement ; il relève de votre responsabilité de consulter régulièrement cette page. Si vous désapprouvez ces conditions, n'adhérez pas à ces services.</p>\n<h3>I. Description des Services</h3>\n<p>FrancoDeal est une plateforme de services destinée aux professionnels du luxe. L’écosystème comprend actuellement trois services principaux : <strong>FrancoDeal Magazine</strong>, magazine éditorial multilingue ; <strong>FrancoDeal Collections</strong>, plateforme éditoriale de découverte et de référencement ; et <strong>FrancoDeal Studio</strong>, décrit ci-dessous.</p>\n<h4>FrancoDeal Studio (studio.francodeal.com)</h4>\n<ul><li>Génération de vidéos à partir de texte ou d'images</li><li>Génération et édition d'images IA</li><li>Création d'avatars IA parlants</li><li>Outils de montage vidéo avec synchronisation audio</li><li>Génération de musique et de voix IA</li><li>Traduction multimédia</li></ul>\n<h4>FrancoDeal Collections (francodeal.com)</h4>\n<p>Plateforme éditoriale de découverte et de référencement réservée aux professionnels du luxe dans des catégories spécifiques (voir section XIV).</p>\n<p><b>Important :</b> Le Service est fourni « tel quel » sans garantie d'absence d'erreurs ou d'interruptions. Pour plus d'informations sur nos forfaits et tarifs, consultez notre page Plans.</p>\n<h3>II. Propriété Intellectuelle</h3>\n<p>Tous les éléments constituant les sites FrancoDeal sont la propriété exclusive de FrancoDeal (marque de Engravethevision LLP) : logos, images, graphismes, textes, contenus, bases de données, vidéos, photographies, noms, marques, code source et architecture technique. Exception est faite pour les éléments réalisés par des intervenants extérieurs n'ayant pas cédé leurs droits d'auteurs, et pour les contenus générés par les utilisateurs via nos services d'IA.</p>\n<p><b>Important :</b> Tout individu naviguant sur FrancoDeal s'engage à ne pas reproduire, copier, modifier, distribuer ou utiliser les données qui le composent sans autorisation préalable écrite.</p>\n<h3>III. Droit à l'Image et Vie Privée</h3>\n<p>Tout utilisateur de FrancoDeal qui publie ou utilise sur le site l'image d'une personne ou un contenu susceptible de porter atteinte à sa vie privée doit avoir obtenu au préalable son autorisation expresse. Il est strictement interdit d'utiliser l'image d'une personne sans son autorisation, y compris si elle est une célébrité ou une personne publique. En utilisant nos services de génération IA, vous certifiez disposer de tous les droits nécessaires sur les contenus que vous soumettez.</p>\n<h3>IV. Règles de Conduite</h3>\n<p>Il est interdit sur les sites FrancoDeal :</p>\n<ul><li>De bénéficier de ses services si vous êtes mineur</li><li>De communiquer des données personnelles confidentielles dans les champs de publications destinés aux internautes</li><li>D'utiliser des services de transfert d'argent internationaux (Western Union, MoneyGram, etc.) entre les utilisateurs</li><li>D'utiliser ses services à des fins illégales</li><li>Toutes références à l'occultisme ou sciences connexes</li><li>De publier tout contenu contraire aux bonnes mœurs et à l'ordre public</li><li>De constituer une infraction pénale (contenus diffamatoires, négationnistes, injurieux, racistes, obscènes, homophobes, pédophiles, sexuels, pornographiques, incitant au meurtre ou au suicide, etc.)</li><li>Toute forme d'escroquerie et d'abus de confiance ou de faiblesse</li><li>D'usurper les informations des utilisateurs</li><li>Toute contrefaçon ou reproduction non autorisée d'une œuvre de l'esprit</li><li>De copier et modifier les données qui composent le site</li><li>De nuire aux intérêts et à la propriété de FrancoDeal et de ses utilisateurs</li><li>De signaler un abus sans raison d'être</li><li>De distribuer des spams, chaînes d'e-mails ou systèmes pyramidaux</li><li>De publier des liens vers un contenu interdit ou illicite</li><li>De publier des contenus à caractère concurrentiel (excepté pour les collaborateurs de FrancoDeal)</li></ul>\n<h3>V. Protection des Données Personnelles</h3>\n<p>Ce site vous permet d'avoir un droit d'accès et de rectification aux informations qui vous concernent, en vous adressant à info@francodeal.com. Pour des motifs légitimes, vous avez la possibilité de vous opposer au traitement de vos données personnelles. Pour plus de détails, consultez notre Politique de Confidentialité.</p>\n<h3>VI. Responsabilités et Exonération</h3>\n<p>FrancoDeal ne garantit pas : l'authenticité et l'exactitude des informations communiquées par les membres ; l'absence d'un mauvais usage par des tiers ; l'absence d'erreurs ou d'interruptions pour cas de force majeure ; que les informations personnelles données par l'utilisateur sont complètes, actuelles et correctes.</p>\n<p>FrancoDeal s'exonère de toute responsabilité en cas d'utilisation anormale, d'exploitation illicite, de perte de mot de passe, d'usurpation d'identité, d'attaque ou de piratage. Les données éditées par les utilisateurs sont sous leur seule responsabilité.</p>\n<p><b>Limitation de responsabilité :</b> Notre responsabilité totale ne dépasse pas le montant que vous avez payé au cours des 12 derniers mois.</p>\n<h3>VII. Utilisation des Cookies</h3>\n<p>Dans le but de faciliter la navigation, des cookies peuvent être implantés dans votre ordinateur afin par exemple de conserver les critères de recherche et vos préférences de langue. Vous avez la possibilité de régler votre navigateur afin de les refuser. Pour plus d'informations, consultez notre Politique de Confidentialité.</p>\n<h3>VIII. Pénalités</h3>\n<p>En cas de non-soumission aux Conditions d'Utilisation, FrancoDeal se réserve le droit de : émettre des avertissements, suspendre temporairement ou indéfiniment un compte, supprimer une information, bloquer une adresse IP, ou imposer toute autre sanction appropriée. FrancoDeal pourra informer les autorités compétentes pour toute diffusion contraire à l'ordre public, aux bonnes mœurs et aux lois en vigueur.</p>\n<h3>IX. Condition de Résiliation</h3>\n<p>Vous pourrez résilier votre inscription à tout moment dans votre compte ou en nous contactant à info@francodeal.com. Les services sont activés aussi longtemps que les paiements sont effectués. Si vous optez pour un abonnement mensuel et ne payez plus, vos services seront interrompus.</p>\n<p><b>Accès après annulation :</b> Votre abonnement reste actif jusqu'à la fin de la période de facturation actuelle. Vos crédits restants restent valides jusqu'à la fin de votre période d'abonnement. Après l'expiration, tous les crédits non utilisés seront perdus.</p>\n<h3>X. Tarification et Abonnements</h3>\n<p>Nous proposons plusieurs plans d'abonnement mensuels et annuels adaptés aux professionnels du luxe. Chaque plan inclut un nombre de crédits pour générer du contenu. Les frais d'abonnement sont facturés automatiquement chaque mois ou année. Votre abonnement se renouvelle automatiquement. Les crédits non utilisés ne sont pas remboursés et ne sont pas reportés. Les crédits ne peuvent pas être échangés en espèces.</p>\n<h3>XI. Modalités de Paiement</h3>\n<h4>11.1 Processeur de Paiement</h4>\n<p>Paiement par carte bancaire via l'interface sécurisée Stripe. Tous les paiements sont chiffrés et sécurisés (PCI DSS Level 1). Nous n'avons jamais accès à vos informations de carte de crédit.</p>\n<h4>11.2 Numéro TPS/TVH</h4><p>766879555RT0001</p>\n<h4>11.3 Paiements Échoués</h4>\n<p>Si votre paiement échoue, nous vous enverrons une notification par email. Vous avez 3 jours pour mettre à jour votre mode de paiement. Après 3 jours, votre abonnement sera suspendu.</p>\n<h3>XII. Politique de Remboursement</h3>\n<p><b>Principe général :</b> Aucun remboursement n'est possible après l'exécution de la prestation.</p>\n<p><b>Délai de remboursement :</b> Vous pouvez demander un remboursement complet dans les 7 jours suivant votre achat initial. Après cette période, aucun remboursement ne peut être accordé.</p>\n<p><b>Conditions d'éligibilité :</b> demande soumise dans les 7 jours après l'achat initial ; aucun crédit utilisé (0%) ; compte en bon état ; première demande de remboursement sur ce compte.</p>\n<p><b>Frais de traitement :</b> Un frais de 7% s'applique aux remboursements (frais Stripe, administratifs et bancaires).</p>\n<p><b>Cas non éligibles :</b> demandes après 7 jours ; crédits utilisés (même partiellement) ; renouvellements d'abonnement ; changements de plan ; violations des conditions d'utilisation.</p>\n<p><b>Comment demander :</b> envoyez un email à info@francodeal.com avec votre numéro de commande, date d'achat et email du compte.</p>\n<h3>XIII. Programme d'Ambassadeurs</h3>\n<p>Les ambassadeurs reçoivent une commission basée sur les ventes générées via leur lien de parrainage. Les commissions varient selon le type de forfait souscrit par le filleul.</p>\n<h3>XIV. Attribution de Juridiction – Loi Applicable</h3>\n<p>Tout litige fera l'objet d'une tentative de règlement amiable. Les présentes conditions générales sont soumises au code de procédure civile de Londres au Royaume-Uni.</p>\n<p>Engravethevision LLP<br>71-75 Shelton Street, Covent Garden, London, United Kingdom, WC2H 9JQ</p>\n<h3>XV. Contact et Support</h3>\n<p>Engravethevision LLP (FrancoDeal)<br>Email : info@francodeal.com · Temps de réponse : 24-48 heures · Site web : francodeal.com</p>\n<p class=\"fd-meta\">Conformité légale : Ces conditions respectent les lois fédérales américaines (FTC Click-to-Cancel Rule), les lois de l'UE (14 jours de rétractation), les lois canadiennes (PIPEDA), les lois du Royaume-Uni (UK GDPR) et les conditions Stripe.</p>\n<p class=\"fd-meta\">© 2026 FrancoDeal (Engravethevision LLP). Tous droits réservés.</p>"}}
