RAE API

Una API no oficial para interactuar con el diccionario de la Real Academia Española

Explorar en GitHub

¿Qué es RAE API?

RAE API es un proyecto independiente que ofrece una interfaz programática para consultar el diccionario de la Real Academia Española. Diseñada específicamente para desarrolladores que necesitan acceso a definiciones, conjugaciones y más detalles del léxico español en sus aplicaciones.

Documentación de la API

Endpoints Disponibles

GET /api/words/{palabra}

Obtiene la información completa de una palabra: definiciones, origen, conjugaciones verbales (si aplica).

Respuesta: 200 OK (éxito) o 404 Not Found (palabra no encontrada)

GET /api/random

Obtiene una palabra aleatoria del diccionario.

Respuesta: 200 OK

GET /api/daily

Obtiene la palabra del día.

Respuesta: 200 OK

Autenticación

La API es de acceso libre para uso no comercial con límites de velocidad razonables.

Para uso intensivo o comercial, contáctenos para obtener una clave API.

Límites de Velocidad

  • Sin autenticación: 60 peticiones/hora
  • Con clave API: 1000 peticiones/hora

Formatos de Respuesta

Todas las respuestas son en formato JSON.

Ejemplos de Uso

Consulta con cURL


# Obtener información de una palabra
curl -X GET "https://rae-api.com/api/words/hablar" -H "Accept: application/json"

# Obtener la palabra del día
curl -X GET "https://rae-api.com/api/daily" -H "Accept: application/json"

# Obtener una palabra aleatoria
curl -X GET "https://rae-api.com/api/random" -H "Accept: application/json"

Consulta con JavaScript


// Obtener definición de una palabra
async function getWordDefinition(word) {
    const response = await fetch(`https://rae-api.com/api/words/${word}`);
    const data = await response.json();
    console.log(data);
}

Consulta con Python


import requests

def get_word_definition(word):
    url = f"https://rae-api.com/api/words/{word}"
    response = requests.get(url)
    if response.status_code == 404:
        print("Palabra no encontrada")
        return None
    if response.status_code != 200:
        print(f"Error: {response.status_code}")
        return None
    return response.json()

Utilizando el SDK Go


package main

import (
    "fmt"
    "log"

    "github.com/rae-api-com/go-rae"
)

func main() {
    client := rae.New()

    // Buscar una palabra
    word, err := client.GetWord("hablar")
    if err != nil {
        log.Fatalf("Error al buscar palabra: %v", err)
    }

    fmt.Printf("Palabra: %s\n", word.Word)

    // Mostrar la primera definición
    if len(word.Meanings) > 0 && len(word.Meanings[0].Senses) > 0 {
        fmt.Printf("Primera definición: %s\n", word.Meanings[0].Senses[0].Raw)
    } else {
        fmt.Println("No se encontraron definiciones.")
    }

    // Verificar si hay conjugaciones (para verbos)
    if len(word.Meanings) > 0 && word.Meanings[0].Conjugations != nil {
        fmt.Println("Esta palabra tiene conjugaciones disponibles")

        // Acceder a las conjugaciones
        conjugations := word.Meanings[0].Conjugations
        fmt.Printf("Infinitivo: %s\n", conjugations.NonPersonal.Infinitive)
        fmt.Printf("Gerundio: %s\n", conjugations.NonPersonal.Gerund)
        fmt.Printf("Participio: %s\n", conjugations.NonPersonal.Participle)
    } else {
        fmt.Println("No se encontraron conjugaciones.")
    }
}

Esquemas JSON

Esquema de Respuesta

A continuación se muestra el esquema JSON de la respuesta de la API al consultar una palabra.

json 
{
  "data": {
    "word": "string",
    "meanings": [
      {
        "origin": {
          "raw": "string",
          "type": "string",
          "voice": "string",
          "text": "string"
        },
        "senses": [
          {
            "raw": "string",
            "meaning_number": number,
            "category": "string",
            "usage": "string",
            "description": "string",
            "synonyms": ["string"],
            "antonyms": ["string"]
          }
        ],
        "conjugations": {
          "non_personal": {
            "infinitive": "string",
            "participle": "string",
            "gerund": "string",
            "compound_infinitive": "string",
            "compound_gerund": "string"
          },
          "indicative": {
            "present": {
              "singular_first_person": "string",
              "singular_second_person": "string",
              "singular_formal_second_person": "string",
              "singular_third_person": "string",
              "plural_first_person": "string",
              "plural_second_person": "string",
              "plural_formal_second_person": "string",
              "plural_third_person": "string"
            },
            "imperfect": { ... },
            "preterite": { ... },
            "future": { ... },
            "conditional": { ... }
          },
          "subjunctive": {
            "present": { ... },
            "imperfect": { ... },
            "future": { ... }
          },
          "imperative": {
            "singular_second_person": "string",
            "singular_formal_second_person": "string",
            "plural_second_person": "string",
            "plural_formal_second_person": "string"
          }
        }
      }
    ]
  },
  "ok": boolean
}

Categorías de Palabras

Las palabras pueden tener las siguientes categorías:

  • noun: Sustantivo
  • verb: Verbo
  • adjective: Adjetivo
  • adverb: Adverbio
  • pronoun: Pronombre
  • article: Artículo
  • preposition: Preposición
  • conjunction: Conjunción
  • interjection: Interjección

Usos Lingüísticos

Los valores posibles para el campo usage:

  • common: Uso común
  • rare: Uso poco común
  • outdated: Anticuado
  • colloquial: Coloquial
  • obsolete: En desuso

Características