Consumir la API en tus proyectos

¿Qué es JSON?, ¿Cómo consumir la API en mis proyectos?, ¿Qué lenguajes puedo usar? y otras preguntas sobre findic.cl.

¿Qué es JSON?

JSON o JavaScript Object Notation, es un formato de texto sencillo utilizado en el intercambio de información a través de internet, especialmente utilizada en aplicaciones móviles y WEB gracias a su facilidad de lectura y su formato estructurado.

Un objeto JSON, se compone principalmente de atributos “clave”: “valor”, un valor puede ser de tipo numérico, texto, listas e incluso otros objetos complejos.

¿Cómo consumir la API en mis proyectos?

Puedes consumir esta API desde cualquier aplicación o componente de software; desde una Aplicación móvil, solicitándolo desde el backend en un servidor o puedes consultar directamente desde tu página web utilizando JavaScript.

¿Tiene un costo?

NO necesitas pagar por utilizar esta API; su uso es completamente gratuito.

¿Necesito un usuario o llave para hacer consultas la API?

NO necesitas tener un usuario, ni utilizar llaves para realizar las consultas. La API es completamente pública y transparente.

¿Qué lenguajes puedo usar?

Puedes utilizar cualquier lenguaje que te permita realizar consultas http (HTTPS) a nuestra API, luego depende de cada lenguaje elegir un mecanismo para transformar/decodificar el JSON a un objeto utilizable (parse, deserialize, etc).

Cabeceras recomendadas

Los ejemplos envían la cabecera User-Agent con un identificador del lenguaje o de la aplicación, por ejemplo findic-docs-java/1.0, salvo en los navegadores, donde el User-Agent lo controla el navegador. Si estás desarrollando una aplicación, reemplázala por el nombre y la versión de tu proyecto (por ejemplo mi-app/2.1.0), así podemos identificar el origen de las consultas.

También recomendamos enviar Accept: application/json para indicar que esperamos un objeto JSON.

En el navegador, JavaScript no permite modificar la cabecera User-Agent; en ese caso el navegador enviará la suya y no es posible cambiarla desde el código.

Ejemplos por lenguaje

1 - PHP

Uso de PHP (Personal Home Page) para obtener datos desde la API de indicadores.

A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje PHP. El ejemplo utiliza cURL y envía la cabecera User-Agent para identificar el cliente.

<?php

$apiUrl = 'https://findic.cl/api/';

$curl = curl_init($apiUrl);
curl_setopt_array($curl, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CONNECTTIMEOUT => 5,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_USERAGENT => 'findic-docs-php/1.0',
    CURLOPT_HTTPHEADER => [
        'Accept: application/json',
    ],
]);

$json = curl_exec($curl);
$status = curl_getinfo($curl, CURLINFO_HTTP_CODE);
$error = curl_error($curl);

if ($json === false || $status !== 200) {
    exit('Error en la solicitud: ' . ($error !== '' ? $error : $status));
}

try {
    // Decodificamos el JSON y lo transformamos en objeto
    $dailyIndicators = json_decode($json, false, 512, JSON_THROW_ON_ERROR);
} catch (JsonException $exception) {
    exit('Error al decodificar el JSON: ' . $exception->getMessage());
}

// Imprimimos el dato de la UF
echo 'El valor actual de la UF es $' . $dailyIndicators->uf->valor;

Si tu servidor no tiene cURL habilitado, puedes usar file_get_contents con un contexto de flujo que incluya las mismas cabeceras User-Agent y Accept.

Más información del objeto JSON entregado en el resumen aquí.

2 - JavaScript

Uso de JavaScript para obtener datos desde la API de indicadores.

A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje JavaScript, este ejemplo te puede ser útil si lo quieres utilizar en tu página web y quieres actualizar el HTML directamente.

async function obtenerUF() {
  try {
    const response = await fetch("https://findic.cl/api/", {
      // Solo recibiremos un objeto JSON
      headers: {
        Accept: "application/json",
      },
      // El método de solicitud que realizaremos (un GET)
      method: "GET",
    });

    // Verificamos que la respuesta sea correcta antes de leer el JSON
    if (!response.ok) {
      throw new Error(`Error en la solicitud: ${response.status}`);
    }

    const data = await response.json();

    // Obtenemos el elemento de nuestro HTML que contenga el ID "UF"
    // (por ejemplo <div id="UF"></div>) y le asignamos el valor de la UF
    document.getElementById("UF").textContent = data.uf.valor;
  } catch (error) {
    console.error(error);
  }
}

obtenerUF();

En el navegador no es posible modificar la cabecera User-Agent, ya que el navegador la controla por seguridad. Si consumes la API desde Node.js, Deno o Bun, agrega "User-Agent": "findic-docs-js/1.0" a las cabeceras de la solicitud.

La cabecera Access-Control-Allow-Origin es una cabecera de respuesta que configura el servidor; no es necesario enviarla desde el cliente.

Más información del objeto JSON entregado en el resumen aquí.

3 - TypeScript

Uso de TypeScript para obtener datos desde la API de indicadores.

A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje TypeScript. El ejemplo utiliza fetch, disponible de forma nativa en Node.js 18+, Deno y Bun, y envía la cabecera User-Agent para identificar el cliente.

interface Indicador {
  codigo: string;
  nombre: string;
  unidad_medida: string;
  fecha: string;
  valor: number;
}

interface Resumen {
  version: string;
  autor: string;
  fecha: string;
  uf: Indicador;
}

async function obtenerResumen(): Promise<Resumen> {
  const response = await fetch("https://findic.cl/api/", {
    method: "GET",
    headers: {
      "User-Agent": "findic-docs-typescript/1.0",
      "Accept": "application/json",
    },
  });

  if (!response.ok) {
    throw new Error(`Error en la solicitud: ${response.status}`);
  }

  return (await response.json()) as Resumen;
}

obtenerResumen()
  .then((data) => {
    console.log(`Fecha: ${data.uf.fecha}`);
    console.log(`Valor UF: $ ${data.uf.valor}`);
  })
  .catch((error) => console.error(error));

En el navegador, User-Agent es una cabecera prohibida y no se puede modificar desde JavaScript o TypeScript; el navegador enviará la suya. En Node.js 18+ fetch está disponible de forma nativa; si tu configuración de TypeScript no lo reconoce, agrega "DOM" a la opción lib de tu tsconfig.json o instala @types/node.

Más información del objeto JSON entregado en el resumen aquí.

4 - Python

Uso de Python para obtener datos desde la API de indicadores.

A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje Python. El ejemplo utiliza requests, reutiliza una sesión y envía la cabecera User-Agent para identificar el cliente.

Si aún no tienes requests, instálalo con:

pip install requests
import requests

# Endpoint de la API para obtener el resumen diario
url = "https://findic.cl/api/"

# Reutilizamos una sesión para enviar las mismas cabeceras en cada consulta
with requests.Session() as session:
    session.headers.update({
        "User-Agent": "findic-docs-python/1.0",
        "Accept": "application/json",
    })

    try:
        response = session.get(url, timeout=10)
        response.raise_for_status()

        data = response.json()

        # Obtenemos el valor de UF
        uf = data["uf"]

        print(f"Fecha: {uf['fecha']}")
        print(f"Valor UF: $ {uf['valor']}")
    except requests.RequestException as error:
        print(f"Error en la solicitud: {error}")

Más información del objeto JSON entregado en el resumen aquí.

5 - Ruby

Uso de Ruby para obtener datos desde la API de indicadores.

A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje Ruby. El ejemplo utiliza Net::HTTP, incluido en la librería estándar, y envía la cabecera User-Agent para identificar el cliente.

require "json"
require "net/http"

uri = URI("https://findic.cl/api/")

request = Net::HTTP::Get.new(uri)
request["User-Agent"] = "findic-docs-ruby/1.0"
request["Accept"] = "application/json"

http = Net::HTTP.new(uri.hostname, uri.port)
http.use_ssl = uri.scheme == "https"
http.open_timeout = 10
http.read_timeout = 10

begin
  response = http.start { |connection| connection.request(request) }

  if response.is_a?(Net::HTTPSuccess)
    data = JSON.parse(response.body)
    uf = data["uf"]

    puts "Fecha: #{uf['fecha']}"
    puts "Valor UF: $ #{uf['valor']}"
  else
    warn "Error en la solicitud: #{response.code}"
  end
rescue StandardError => error
  warn "Error en la solicitud: #{error.message}"
end

Más información del objeto JSON entregado en el resumen aquí.

6 - R

Uso de R para obtener datos desde la API de indicadores.

A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje R. El ejemplo utiliza httr2 y envía la cabecera User-Agent para identificar el cliente.

Instala los paquetes si aún no los tienes:

install.packages(c("httr2", "jsonlite"))
library(httr2)

url <- "https://findic.cl/api/"

tryCatch(
  {
    respuesta <- request(url) |>
      req_user_agent("findic-docs-r/1.0") |>
      req_headers(Accept = "application/json") |>
      req_timeout(10) |>
      req_perform()

    resumen <- resp_body_json(respuesta)
    uf <- resumen$uf

    cat("Fecha:", uf$fecha, "\n")
    cat("Valor UF: $", uf$valor, "\n")
  },
  error = function(error) {
    cat("Error en la solicitud:", conditionMessage(error), "\n")
  }
)

Más información del objeto JSON entregado en el resumen aquí.

7 - Java

Uso de Java para obtener datos desde la API de indicadores.

A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje Java. El ejemplo utiliza java.net.http.HttpClient, incluido desde Java 11, y Jackson para leer el JSON. Además, envía la cabecera User-Agent para identificar el cliente.

Si usas Maven, agrega la dependencia de Jackson:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.18.2</version>
</dependency>
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class FindicExample {

    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(10))
                .followRedirects(HttpClient.Redirect.NORMAL)
                .build();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://findic.cl/api/"))
                .timeout(Duration.ofSeconds(10))
                .header("User-Agent", "findic-docs-java/1.0")
                .header("Accept", "application/json")
                .GET()
                .build();

        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        if (response.statusCode() != 200) {
            System.err.println("Error en la solicitud: " + response.statusCode());
            return;
        }

        JsonNode data = new ObjectMapper().readTree(response.body());
        JsonNode uf = data.get("uf");

        System.out.println("Fecha: " + uf.get("fecha").asText());
        System.out.println("Valor UF: $ " + uf.get("valor").asDouble());
    }
}

Más información del objeto JSON entregado en el resumen aquí.

8 - Kotlin

Uso de Kotlin para obtener datos desde la API de indicadores.

A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje Kotlin. El ejemplo está pensado para Kotlin/JVM, por lo que funciona en Android, backend o aplicaciones de escritorio. Utiliza OkHttp y kotlinx.serialization, y envía la cabecera User-Agent para identificar el cliente.

Agrega las dependencias y el plugin de serialización a tu proyecto:

plugins {
    kotlin("jvm") version "2.4.21"
    kotlin("plugin.serialization") version "2.4.21"
}

dependencies {
    implementation("com.squareup.okhttp3:okhttp:4.12.0")
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
}
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import okhttp3.OkHttpClient
import okhttp3.Request
import java.util.concurrent.TimeUnit

@Serializable
data class Indicador(
    val fecha: String,
    val valor: Double,
)

@Serializable
data class Resumen(
    val uf: Indicador,
)

fun main() {
    val client = OkHttpClient.Builder()
        .connectTimeout(10, TimeUnit.SECONDS)
        .readTimeout(10, TimeUnit.SECONDS)
        .build()

    val request = Request.Builder()
        .url("https://findic.cl/api/")
        .header("User-Agent", "findic-docs-kotlin/1.0")
        .header("Accept", "application/json")
        .get()
        .build()

    try {
        client.newCall(request).execute().use { response ->
            if (!response.isSuccessful) {
                error("Error en la solicitud: ${response.code}")
            }

            val body = response.body?.string() ?: error("Respuesta vacía")
            val json = Json { ignoreUnknownKeys = true }
            val resumen = json.decodeFromString<Resumen>(body)

            println("Fecha: ${resumen.uf.fecha}")
            println("Valor UF: $ ${resumen.uf.valor}")
        }
    } catch (exception: Exception) {
        println("Error en la solicitud: ${exception.message}")
    }
}

En Android, recuerda agregar <uses-permission android:name="android.permission.INTERNET" /> en el AndroidManifest.xml.

Más información del objeto JSON entregado en el resumen aquí.

9 - C#

Uso de C# (.NET) para obtener datos desde la API de indicadores.

A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje C#. El ejemplo utiliza HttpClient y System.Text.Json, incluidos en .NET, y envía la cabecera User-Agent para identificar el cliente.

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    // Reutilizamos una sola instancia de HttpClient durante toda la aplicación
    private static readonly HttpClient Client = new HttpClient
    {
        Timeout = TimeSpan.FromSeconds(10)
    };

    static async Task Main()
    {
        Client.DefaultRequestHeaders.UserAgent.ParseAdd("findic-docs-dotnet/1.0");
        Client.DefaultRequestHeaders.Accept.Add(
            new MediaTypeWithQualityHeaderValue("application/json")
        );

        try
        {
            using HttpResponseMessage response = await Client.GetAsync(
                "https://findic.cl/api/"
            );
            response.EnsureSuccessStatusCode();

            string json = await response.Content.ReadAsStringAsync();
            using JsonDocument document = JsonDocument.Parse(json);
            JsonElement uf = document.RootElement.GetProperty("uf");

            Console.WriteLine($"Fecha: {uf.GetProperty("fecha").GetString()}");
            Console.WriteLine($"Valor UF: $ {uf.GetProperty("valor").GetDecimal()}");
        }
        catch (HttpRequestException error)
        {
            Console.WriteLine($"Error en la solicitud: {error.Message}");
        }
    }
}

Más información del objeto JSON entregado en el resumen aquí.

10 - Go

Uso de Go para obtener datos desde la API de indicadores.

A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje Go. El ejemplo utiliza la librería estándar net/http y envía la cabecera User-Agent para identificar el cliente.

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"time"
)

type Indicador struct {
	Fecha string  `json:"fecha"`
	Valor float64 `json:"valor"`
}

type Resumen struct {
	UF Indicador `json:"uf"`
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(
		ctx,
		http.MethodGet,
		"https://findic.cl/api/",
		nil,
	)
	if err != nil {
		fmt.Println("Error al crear la solicitud:", err)
		return
	}

	req.Header.Set("User-Agent", "findic-docs-go/1.0")
	req.Header.Set("Accept", "application/json")

	client := &http.Client{Timeout: 10 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Error en la solicitud:", err)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		fmt.Println("Error en la solicitud:", resp.StatusCode)
		return
	}

	var resumen Resumen
	if err := json.NewDecoder(resp.Body).Decode(&resumen); err != nil {
		fmt.Println("Error al decodificar el JSON:", err)
		return
	}

	fmt.Println("Fecha:", resumen.UF.Fecha)
	fmt.Printf("Valor UF: $ %.2f\n", resumen.UF.Valor)
}

Más información del objeto JSON entregado en el resumen aquí.

11 - Rust

Uso de Rust para obtener datos desde la API de indicadores.

A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje Rust. El ejemplo utiliza reqwest y serde, y envía la cabecera User-Agent para identificar el cliente.

Agrega las dependencias a tu Cargo.toml:

[dependencies]
reqwest = { version = "0.12", features = ["blocking", "json"] }
serde = { version = "1", features = ["derive"] }
use reqwest::blocking::Client;
use serde::Deserialize;
use std::time::Duration;

#[derive(Debug, Deserialize)]
struct Indicador {
    fecha: String,
    valor: f64,
}

#[derive(Debug, Deserialize)]
struct Resumen {
    uf: Indicador,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::builder()
        .user_agent("findic-docs-rust/1.0")
        .timeout(Duration::from_secs(10))
        .build()?;

    let resumen: Resumen = client
        .get("https://findic.cl/api/")
        .header(reqwest::header::ACCEPT, "application/json")
        .send()?
        .error_for_status()?
        .json()?;

    println!("Fecha: {}", resumen.uf.fecha);
    println!("Valor UF: $ {:.2}", resumen.uf.valor);

    Ok(())
}

Más información del objeto JSON entregado en el resumen aquí.

12 - Swift

Uso de Swift para obtener datos desde la API de indicadores.

A continuación se muestra el código de ejemplo para consultar a nuestra API desde el Lenguaje Swift. El ejemplo utiliza URLSession y Codable, y envía la cabecera User-Agent para identificar el cliente.

import Foundation

struct Indicador: Decodable {
    let fecha: String
    let valor: Double
}

struct Resumen: Decodable {
    let uf: Indicador
}

@main
struct FindicExample {
    static func main() async {
        guard let url = URL(string: "https://findic.cl/api/") else {
            print("URL inválida")
            return
        }

        let configuration = URLSessionConfiguration.default
        configuration.httpAdditionalHeaders = [
            "User-Agent": "findic-docs-swift/1.0",
            "Accept": "application/json"
        ]
        configuration.timeoutIntervalForRequest = 10

        let session = URLSession(configuration: configuration)

        do {
            let (data, response) = try await session.data(from: url)

            guard let httpResponse = response as? HTTPURLResponse,
                  httpResponse.statusCode == 200 else {
                print("Error en la solicitud")
                return
            }

            let resumen = try JSONDecoder().decode(Resumen.self, from: data)

            print("Fecha: \(resumen.uf.fecha)")
            print("Valor UF: $ \(resumen.uf.valor)")
        } catch {
            print("Error en la solicitud: \(error)")
        }
    }
}

El ejemplo utiliza async/await y URLSession.data(from:), disponibles desde iOS 15, macOS 12 y Swift 5.5.

Si compilas el ejemplo como un ejecutable de un solo archivo, agrega -parse-as-library a swiftc; de lo contrario, @main se considera código de nivel superior.

Más información del objeto JSON entregado en el resumen aquí.

13 - Flutter (Dart)

Uso de Flutter (Dart) para obtener datos desde la API de indicadores.

A continuación se muestra el código de ejemplo para consultar a nuestra API desde Flutter. El ejemplo utiliza el paquete http y envía la cabecera User-Agent para identificar el cliente.

Agrega la dependencia a tu proyecto:

flutter pub add http
import 'dart:convert';

import 'package:http/http.dart' as http;

Future<void> main() async {
  final uri = Uri.parse('https://findic.cl/api/');

  try {
    final response = await http.get(
      uri,
      headers: {
        'User-Agent': 'findic-docs-flutter/1.0',
        'Accept': 'application/json',
      },
    );

    if (response.statusCode != 200) {
      print('Error en la solicitud: ${response.statusCode}');
      return;
    }

    final data = jsonDecode(response.body) as Map<String, dynamic>;
    final uf = data['uf'] as Map<String, dynamic>;

    print('Fecha: ${uf['fecha']}');
    print('Valor UF: \$ ${uf['valor']}');
  } catch (error) {
    print('Error en la solicitud: $error');
  }
}

En Flutter Web el navegador controla la cabecera User-Agent y no es posible modificarla desde Dart. En Android, iOS, macOS, Windows y Linux sí se envía la cabecera indicada.

Más información del objeto JSON entregado en el resumen aquí.

14 - Lazarus

Uso de Lazarus (Free Pascal) para obtener datos desde la API de indicadores.

A continuación se muestra el código de ejemplo para consultar a nuestra API desde Lazarus (Free Pascal). El ejemplo utiliza TFPHTTPClient y fpjson, incluidos en Lazarus, y envía la cabecera User-Agent para identificar el cliente.

program FindicExample;

{$mode objfpc}{$H+}

uses
  SysUtils, fphttpclient, fpjson, jsonparser, opensslsockets;

var
  Client: TFPHTTPClient;
  JSONValue: TJSONData;
  Resumen: TJSONObject;
  UF: TJSONObject;
begin
  Client := TFPHTTPClient.Create(nil);
  try
    Client.AddHeader('User-Agent', 'findic-docs-lazarus/1.0');
    Client.AddHeader('Accept', 'application/json');
    Client.ConnectTimeout := 10000;
    Client.IOTimeout := 10000;

    try
      JSONValue := GetJSON(Client.Get('https://findic.cl/api/'));
      if not (JSONValue is TJSONObject) then
      begin
        JSONValue.Free;
        Writeln('Error al decodificar el JSON');
        Exit;
      end;

      Resumen := TJSONObject(JSONValue);
      try
        UF := Resumen.Objects['uf'];
        Writeln('Fecha: ', UF.Strings['fecha']);
        Writeln('Valor UF: $ ', UF.Floats['valor']:0:2);
      finally
        Resumen.Free;
      end;
    except
      on E: Exception do
        Writeln('Error en la solicitud: ', E.Message);
    end;
  finally
    Client.Free;
  end;
end.

Más información del objeto JSON entregado en el resumen aquí.

En macOS con Homebrew, si aparece Could not initialize OpenSSL library, instala openssl@1.1 (brew install openssl@1.1) y ejecuta el programa con DYLD_LIBRARY_PATH="$(brew --prefix openssl@1.1)/lib".