0Pricing
Next.js 15 Fullstack Web Apps · Leçon

Intégrer des services externes

Connectez votre serveur principal Next.js à des API et services tiers pour étendre ses fonctionnalités.

Intégrer des services externes est une leçon Next.js 15 Fullstack Web Apps gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Next.js 15 Fullstack Web Apps, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Next.js 15 Fullstack Web Apps comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Connect Your App to the World

Modern web applications rarely exist in isolation. They often need to interact with other services to provide rich features.

  • Payment Gateways: Stripe, PayPal.
  • Authentication: Auth0, Clerk.
  • Data Services: Weather APIs, stock prices.
  • Email & SMS: SendGrid, Twilio.

Integrating these external services expands your app's capabilities immensely!

Your Next.js Backend Hub

In Next.js, the ideal place for making server-side calls to external APIs is within Route Handlers.

Route Handlers run on the server, meaning your API keys and sensitive logic stay secure and are never exposed to the client (browser).

They act like your own custom backend API endpoints.

Fetching Data with `fetch()`

The standard way to make network requests in JavaScript, including in Next.js Route Handlers, is using the built-in fetch() API.

For a basic GET request, you just need the URL. Let's try fetching some public data!

async function getJoke() {
  try {
    const response = await fetch('https://api.chucknorris.io/jokes/random');
    if (!response.ok) {
      throw new Error(`HTTP error! Status: ${response.status}`);
    }
    const data = await response.json();
    console.log("Chuck Norris Joke:");
    console.log(data.value);
  } catch (error) {
    console.error("Failed to fetch joke:", error);
  }
}

getJoke();

Guarding Your Credentials

When integrating with most external services, you'll need an API Key or secret.

Never hardcode these directly in your code or expose them to the client-side! This is a major security risk.

Instead, store them as environment variables, typically in a .env.local file in your project root.

Accessing Secure Keys

Next.js automatically loads environment variables from .env.local. You can access them in your server-side code (like Route Handlers) using process.env.YOUR_VARIABLE_NAME.

Remember, variables prefixed with NEXT_PUBLIC_ are exposed to the browser, so avoid this for secrets!

// .env.local
EXTERNAL_API_KEY=your_super_secret_key_123

// In a Route Handler (e.g., app/api/data/route.js)
import { NextResponse } from 'next/server';

export async function GET() {
  const apiKey = process.env.EXTERNAL_API_KEY;
  if (!apiKey) {
    return NextResponse.json({ error: 'API Key not configured' }, { status: 500 });
  }
  // Use apiKey in your fetch call
  // const response = await fetch(`https://api.external.com/data?key=${apiKey}`);
  return NextResponse.json({ message: 'API Key accessed successfully!' });
}

Submitting Data to Services

Often, you need to send data to an external service, not just receive it. This is typically done with a POST request.

With fetch(), you specify the method: 'POST', set headers (especially 'Content-Type': 'application/json'), and include your data in the body, usually as a JSON string.

async function sendData() {
  const postData = {
    title: 'New Post from CoddyKit',
    body: 'This is a test post sent to an external service.',
    userId: 1,
  };

  try {
    const response = await fetch('https://jsonplaceholder.typicode.com/posts', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(postData),
    });

    if (!response.ok) {
      throw new Error(`HTTP error! Status: ${response.status}`);
    }

    const result = await response.json();
    console.log("Post created successfully:");
    console.log(result); // The external service often returns the created item
  } catch (error) {
    console.error("Failed to send data:", error);
  }
}

sendData();

When Things Go Wrong

External services can fail due to network issues, invalid data, rate limits, or server errors. Your application needs to handle these gracefully.

  • Always wrap fetch calls in a try...catch block.
  • Check response.ok (a boolean) to see if the HTTP status code was in the 200-299 range.
  • Handle different status codes (e.g., 401 Unauthorized, 404 Not Found, 500 Server Error) appropriately.

Smart Integration Strategies

To build reliable integrations, consider these best practices:

  • Timeouts: Prevent your app from hanging indefinitely if an external service is slow.
  • Retries: Implement a retry mechanism for transient errors (e.g., network glitches).
  • Idempotency: Design your requests so that making the same request multiple times has the same effect as making it once (important for payments).

For complex scenarios, libraries like axios or node-fetch (for older Node versions) offer more features, but native fetch is often sufficient.

Check Your Understanding

It's crucial to securely handle sensitive information when interacting with external services.

Connecting Your App

You've learned how to integrate external services into your Next.js application.

  • Route Handlers are your secure server-side gateway.
  • The fetch() API handles GET and POST requests.
  • Always use environment variables for API keys and keep them server-side.
  • Implement robust error handling and consider best practices like timeouts and retries.

This skill is fundamental for building feature-rich, fullstack applications!

Questions Fréquemment Posées

La leçon « Intégrer des services externes » est-elle gratuite ?

Oui — le texte complet de « Intégrer des services externes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Next.js 15 Fullstack Web Apps, passe à CoddyKit PRO. Le cours Next.js 15 Fullstack Web Apps comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Intégrer des services externes » ?

Connectez votre serveur principal Next.js à des API et services tiers pour étendre ses fonctionnalités. Tu pratiques Next.js 15 Fullstack Web Apps avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Next.js 15 Fullstack Web Apps ?

Aucune expérience préalable n'est requise. Next.js 15 Fullstack Web Apps sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Intégrer des services externes » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Next.js 15 Fullstack Web Apps ?

Oui. Chaque leçon Next.js 15 Fullstack Web Apps inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Créer des gestionnaires de routes d’API
  2. Validation des requêtes et sécurité
  3. Intégrer des services externes
  4. Limitation du débit et gestion des erreurs d’API
← Retour à Next.js 15 Fullstack Web Apps